Revert of Adding bulk plot reffer to cached textblobs

src/gpu/GrBatchAtlas.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrBatchAtlas.h"
 #include "GrBatchTarget.h"
 #include "GrGpu.h"
 #include "GrRectanizer.h"
 #include "GrTracing.h"
 
+// for testing
+#define ATLAS_STATS 0
+#if ATLAS_STATS
+static int g_UploadCount = 0;
+#endif
+
 static inline void adjust_for_offset(SkIPoint16* loc, const SkIPoint16& offset) {
     loc->fX += offset.fX;
     loc->fY += offset.fY;
 }
 
 static GrBatchAtlas::AtlasID create_id(int index, int generation) {
     // Generation ID can roll over because we only check for equality
     SkASSERT(index < (1 << 16));
     return generation << 16 | index;
 }
@@ skipping 36 matching lines @@
         for (int i = 0; i < height; ++i) {
             memcpy(dataPtr, imagePtr, rowBytes);
             dataPtr += fBytesPerPixel * fWidth;
             imagePtr += rowBytes;
         }
 
         fDirtyRect.join(loc->fX, loc->fY, loc->fX + width, loc->fY + height);
         adjust_for_offset(loc, fOffset);
         SkDEBUGCODE(fDirty = true;)
 
+#if ATLAS_STATS
+        ++g_UploadCount;
+#endif
+
         return true;
     }
 
     // to manage the lifetime of a plot, we use two tokens.  We use last upload token to know when
     // we can 'piggy back' uploads, ie if the last upload hasn't been flushed to gpu, we don't need
     // to issue a new upload even if we update the cpu backing store.  We use lastref to determine
     // when we can evict a plot from the cache, ie if the last ref has already flushed through
     // the gpu then we can reuse the plot
     BatchToken lastUploadToken() const { return fLastUpload; }
-    BatchToken lastUseToken() const { return fLastUse; }
-    void setLastUploadToken(BatchToken batchToken) {
-        SkASSERT(batchToken >= fLastUpload);
-        fLastUpload = batchToken;
-    }
-    void setLastUseToken(BatchToken batchToken) {
-        SkASSERT(batchToken >= fLastUse);
-        fLastUse = batchToken;
-    }
+    BatchToken lastRefToken() const { return fLastRef; }
+    void setLastUploadToken(BatchToken batchToken) { fLastUpload = batchToken; }
+    void setLastRefToken(BatchToken batchToken) { fLastRef = batchToken; }
 
     void uploadToTexture(GrBatchTarget::TextureUploader uploader)  {
         // We should only be issuing uploads if we are in fact dirty
         SkASSERT(fDirty);
         TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("skia.gpu"), "GrBatchPlot::uploadToTexture");
         SkASSERT(fTexture);
         size_t rowBytes = fBytesPerPixel * fRects->width();
         const unsigned char* dataPtr = fData;
         dataPtr += rowBytes * fDirtyRect.fTop;
         dataPtr += fBytesPerPixel * fDirtyRect.fLeft;
@@ skipping 18 matching lines @@
         fDirtyRect.setEmpty();
         SkDEBUGCODE(fDirty = false;)
     }
 
     int x() const { return fX; }
     int y() const { return fY; }
 
 private:
     BatchPlot()
         : fLastUpload(0)
-        , fLastUse(0)
+        , fLastRef(0)
         , fIndex(-1)
         , fGenID(-1)
         , fID(0)
         , fData(NULL)
         , fWidth(0)
         , fHeight(0)
         , fX(0)
         , fY(0)
         , fTexture(NULL)
         , fRects(NULL)
@@ skipping 29 matching lines @@
         fDirtyRect.setEmpty();
         SkDEBUGCODE(fDirty = false;)
         fTexture = texture;
 
         // allocate backing store
         fData = SkNEW_ARRAY(unsigned char, fBytesPerPixel * width * height);
         memset(fData, 0, fBytesPerPixel * width * height);
     }
 
     BatchToken fLastUpload;
-    BatchToken fLastUse;
+    BatchToken fLastRef;
 
     uint32_t fIndex;
     uint32_t fGenID;
     GrBatchAtlas::AtlasID fID;
     unsigned char* fData;
     int fWidth;
     int fHeight;
     int fX;
     int fY;
     GrTexture* fTexture;
@@ skipping 31 matching lines @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
 GrBatchAtlas::GrBatchAtlas(GrTexture* texture, int numPlotsX, int numPlotsY)
     : fTexture(texture)
     , fNumPlotsX(numPlotsX)
     , fNumPlotsY(numPlotsY)
     , fPlotWidth(texture->width() / numPlotsX)
     , fPlotHeight(texture->height() / numPlotsY)
     , fAtlasGeneration(kInvalidAtlasGeneration + 1) {
-    SkASSERT(fNumPlotsX * fNumPlotsY <= BulkUseTokenUpdater::kMaxPlots);
     SkASSERT(fPlotWidth * fNumPlotsX == texture->width());
     SkASSERT(fPlotHeight * fNumPlotsY == texture->height());
 
     // We currently do not support compressed atlases...
     SkASSERT(!GrPixelConfigIsCompressed(texture->desc().fConfig));
 
     // set up allocated plots
     fBPP = GrBytesPerPixel(texture->desc().fConfig);
     fPlotArray = SkNEW_ARRAY(SkAutoTUnref<BatchPlot>, (fNumPlotsX * fNumPlotsY));
 
     SkAutoTUnref<BatchPlot>* currPlot = fPlotArray;
     for (int y = fNumPlotsY - 1, r = 0; y >= 0; --y, ++r) {
         for (int x = fNumPlotsX - 1, c = 0; x >= 0; --x, ++c) {
             int id = r * fNumPlotsX + c;
             currPlot->reset(SkNEW(BatchPlot));
             (*currPlot)->init(this, texture, id, 1, x, y, fPlotWidth, fPlotHeight, fBPP);
 
             // build LRU list
             fPlotList.addToHead(currPlot->get());
             ++currPlot;
         }
     }
 }
 
 GrBatchAtlas::~GrBatchAtlas() {
     SkSafeUnref(fTexture);
     SkDELETE_ARRAY(fPlotArray);
+
+#if ATLAS_STATS
+      SkDebugf("Num uploads: %d\n", g_UploadCount);
+#endif
 }
 
 void GrBatchAtlas::processEviction(AtlasID id) {
     for (int i = 0; i < fEvictionCallbacks.count(); i++) {
         (*fEvictionCallbacks[i].fFunc)(id, fEvictionCallbacks[i].fData);
     }
 }
 
 void GrBatchAtlas::makeMRU(BatchPlot* plot) {
     if (fPlotList.head() == plot) {
@@ skipping 33 matching lines @@
             return true;
         }
         plotIter.next();
     }
 
     // If the above fails, then see if the least recently refed plot has already been flushed to the
     // gpu
     plotIter.init(fPlotList, GrBatchPlotList::Iter::kTail_IterStart);
     plot = plotIter.get();
     SkASSERT(plot);
-    if (batchTarget->isIssued(plot->lastUseToken())) {
+    if (batchTarget->isIssued(plot->lastRefToken())) {
         this->processEviction(plot->id());
         plot->resetRects();
         SkDEBUGCODE(bool verify = )plot->addSubImage(width, height, image, loc, fBPP * width);
         SkASSERT(verify);
         this->updatePlot(batchTarget, id, plot);
         fAtlasGeneration++;
         return true;
     }
 
     // The least recently refed plot hasn't been flushed to the gpu yet, however, if we have flushed
     // it to the batch target than we can reuse it.  Our last ref token is guaranteed to be less
     // than or equal to the current token.  If its 'less than' the current token, than we can spin
     // off the plot(ie let the batch target manage it) and create a new plot in its place in our
     // array.  If it is equal to the currentToken, then the caller has to flush draws to the batch
     // target so we can spin off the plot
-    if (plot->lastUseToken() == batchTarget->currentToken()) {
+    if (plot->lastRefToken() == batchTarget->currentToken()) {
         return false;
     }
 
     // We take an extra ref here so our plot isn't deleted when we reset its index in the array.
     plot->ref();
     int index = plot->index();
     int x = plot->x();
     int y = plot->y();
     int generation = plot->genID();
 
     this->processEviction(plot->id());
     fPlotList.remove(plot);
     SkAutoTUnref<BatchPlot>& newPlot = fPlotArray[plot->index()];
     newPlot.reset(SkNEW(BatchPlot));
     newPlot->init(this, fTexture, index, ++generation, x, y, fPlotWidth, fPlotHeight, fBPP);
 
     fPlotList.addToHead(newPlot.get());
     SkDEBUGCODE(bool verify = )newPlot->addSubImage(width, height, image, loc, fBPP * width);
     SkASSERT(verify);
     newPlot->setLastUploadToken(batchTarget->currentToken());
     SkAutoTUnref<GrPlotUploader> uploader(SkNEW_ARGS(GrPlotUploader, (newPlot)));
     batchTarget->upload(uploader);
     *id = newPlot->id();
     plot->unref();
     fAtlasGeneration++;
     return true;
 }
 
 bool GrBatchAtlas::hasID(AtlasID id) {
-    int index = GetIndexFromID(id);
+    int index = this->getIndexFromID(id);
     SkASSERT(index < fNumPlotsX * fNumPlotsY);
-    return fPlotArray[index]->genID() == GetGenerationFromID(id);
+    return fPlotArray[index]->genID() == this->getGenerationFromID(id);
 }
 
-void GrBatchAtlas::setLastUseToken(AtlasID id, BatchToken batchToken) {
+void GrBatchAtlas::setLastRefToken(AtlasID id, BatchToken batchToken) {
     SkASSERT(this->hasID(id));
-    int index = GetIndexFromID(id);
-    SkASSERT(index < fNumPlotsX * fNumPlotsY);
+    int index = this->getIndexFromID(id);
     this->makeMRU(fPlotArray[index]);
-    fPlotArray[index]->setLastUseToken(batchToken);
+    fPlotArray[index]->setLastRefToken(batchToken);
 }
-
-void GrBatchAtlas::setLastUseTokenBulk(const BulkUseTokenUpdater& updater, BatchToken batchToken) {
-    int plotsToUpdateCount = updater.fPlotsToUpdate.count();
-    for (int i = 0; i < plotsToUpdateCount; i++) {
-        BatchPlot* plot = fPlotArray[updater.fPlotsToUpdate[i]];
-        this->makeMRU(plot);
-        plot->setLastUseToken(batchToken);
-    }
-}