Simplify GrDrawBatch uploads and token uage.

src/gpu/GrBatchFlushState.h

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrBatchBuffer_DEFINED
 #define GrBatchBuffer_DEFINED
 
 #include "GrBufferAllocPool.h"
 #include "batches/GrVertexBatch.h"
 
 class GrResourceProvider;
 
-/** Simple class that performs the upload on behalf of a GrBatchUploader. */
-class GrBatchUploader::TextureUploader {
-public:
-    TextureUploader(GrGpu* gpu) : fGpu(gpu) { SkASSERT(gpu); }
-
-    /**
-        * Updates the pixels in a rectangle of a texture.
-        *
-        * @param left          left edge of the rectangle to write (inclusive)
-        * @param top           top edge of the rectangle to write (inclusive)
-        * @param width         width of rectangle to write in pixels.
-        * @param height        height of rectangle to write in pixels.
-        * @param config        the pixel config of the source buffer
-        * @param buffer        memory to read pixels from
-        * @param rowBytes      number of bytes between consecutive rows. Zero
-        *                      means rows are tightly packed.
-        */
-    bool writeTexturePixels(GrTexture* texture,
-                            int left, int top, int width, int height,
-                            GrPixelConfig config, const void* buffer,
-                            size_t rowBytes) {
-        return fGpu->writePixels(texture, left, top, width, height, config, buffer, rowBytes);
-    }
-
-private:
-    GrGpu* fGpu;
-};
-
 /** Tracks the state across all the GrBatches in a GrDrawTarget flush. */
 class GrBatchFlushState {
 public:
     GrBatchFlushState(GrGpu*, GrResourceProvider*);
 
     ~GrBatchFlushState() { this->reset(); }
 
-    void advanceToken() { ++fCurrentToken; }
-
-    void advanceLastFlushedToken() { ++fLastFlushedToken; }
-
-    /** Inserts an upload to be executred after all batches in the flush prepared their draws
+    /** Inserts an upload to be executed after all batches in the flush prepared their draws
         but before the draws are executed to the backend 3D API. */
-    void addASAPUpload(GrBatchUploader* upload) {
-        fAsapUploads.push_back().reset(SkRef(upload));
+    void addASAPUpload(GrDrawBatch::DeferredUploadFn&& upload) {
+        fAsapUploads.emplace_back(std::move(upload));
     }
 
     const GrCaps& caps() const { return *fGpu->caps(); }
     GrResourceProvider* resourceProvider() const { return fResourceProvider; }
 
     /** Has the token been flushed to the backend 3D API. */
-    bool hasTokenBeenFlushed(GrBatchToken token) const { return fLastFlushedToken >= token; }
+    bool hasDrawBeenFlushed(GrBatchDrawToken token) const {
+        return token.fSequenceNumber <= fLastFlushedToken.fSequenceNumber;
+    }
 

[robertphillips, 2016/03/30 14:29:47]

a an -> an ?

[bsalomon, 2016/03/30 16:59:10]

Done.

-    /** The current token advances once for every contiguous set of uninterrupted draws prepared
-        by a batch. */
-    GrBatchToken currentToken() const { return fCurrentToken; }
+    /** Issue a token to a an operation that is being enqueued. */
+    GrBatchDrawToken issueDrawToken() {
+        return GrBatchDrawToken(++fLastIssuedToken.fSequenceNumber);
+    }
+
+    /** Call every time a draw that was issued a token is flushed */
+    void flushToken() { ++fLastFlushedToken.fSequenceNumber; }
+
+    /** Gets the next draw token that will be issued. */
+    GrBatchDrawToken nextDrawToken() const {
+        return GrBatchDrawToken(fLastIssuedToken.fSequenceNumber + 1);
+    }
 
     /** The last token flushed to all the way to the backend API. */
-    GrBatchToken lastFlushedToken() const { return fLastFlushedToken; }
-
-    /** This is a magic token that can be used to indicate that an upload should occur before
-        any draws for any batch in the current flush execute. */
-    GrBatchToken asapToken() const { return fLastFlushedToken + 1; }
+    GrBatchDrawToken nextTokenToFlush() const {
+        return GrBatchDrawToken(fLastFlushedToken.fSequenceNumber + 1);
+    }
 
     void* makeVertexSpace(size_t vertexSize, int vertexCount,
                           const GrBuffer** buffer, int* startVertex);
     uint16_t* makeIndexSpace(int indexCount, const GrBuffer** buffer, int* startIndex);
 
     /** This is called after each batch has a chance to prepare its draws and before the draws
         are issued. */
     void preIssueDraws() {
         fVertexPool.unmap();
         fIndexPool.unmap();
         int uploadCount = fAsapUploads.count();
+
         for (int i = 0; i < uploadCount; i++) {
-            fAsapUploads[i]->upload(&fUploader);
+            this->doUpload(fAsapUploads[i]);
         }
         fAsapUploads.reset();
     }
 
+    void doUpload(GrDrawBatch::DeferredUploadFn& upload) {
+        GrDrawBatch::WritePixelsFn wp = [this] (GrSurface* surface,
+                int left, int top, int width, int height,
+                GrPixelConfig config, const void* buffer,
+                size_t rowBytes) -> bool {
+            return this->fGpu->writePixels(surface, left, top, width, height, config, buffer,
+                                           rowBytes);
+        };
+        upload(wp);
+    }
+
     void putBackIndices(size_t indices) { fIndexPool.putBack(indices * sizeof(uint16_t)); }
 
     void putBackVertexSpace(size_t sizeInBytes) { fVertexPool.putBack(sizeInBytes); }
 
-    GrBatchUploader::TextureUploader* uploader() { return &fUploader; }
-
     GrGpu* gpu() { return fGpu; }
 
     void reset() {
         fVertexPool.reset();
         fIndexPool.reset();
     }
 
 private:
-    GrGpu*                                          fGpu;
-    GrBatchUploader::TextureUploader                fUploader;
 
-    GrResourceProvider*                             fResourceProvider;
+    GrGpu*                                              fGpu;
 
-    GrVertexBufferAllocPool                         fVertexPool;
-    GrIndexBufferAllocPool                          fIndexPool;
+    GrResourceProvider*                                 fResourceProvider;
 
-    SkTArray<SkAutoTUnref<GrBatchUploader>, true>   fAsapUploads;
+    GrVertexBufferAllocPool                             fVertexPool;
+    GrIndexBufferAllocPool                              fIndexPool;
 
-    GrBatchToken                                    fCurrentToken;
+    SkSTArray<4, GrDrawBatch::DeferredUploadFn>         fAsapUploads;
 
-    GrBatchToken                                    fLastFlushedToken;
+    GrBatchDrawToken                                    fLastIssuedToken;
+
+    GrBatchDrawToken                                    fLastFlushedToken;
 };
 
 /**
+ * A word about uploads and tokens: Batches should usually schedule their uploads to occur at the
+ * begining of a frame whenever possible. These are called ASAP uploads. Of course, this requires
+ * that there are no draws that have yet to be flushed that rely on the old texture contents. In
+ * that case the ASAP upload would happen prior to the previous draw causing the draw to read the
+ * new (wrong) texture data. In that case they should schedule an inline upload.
+ *
+ * Batches, in conjunction with helpers such as GrBatchAtlas, can use the token system to know
+ * what the most recent draw was that referenced a resource (or portion of a resource). Each draw
+ * is assigned a token. A resource (or portion) can be tagged with the most recent draw's
+ * token. The target provides a facility for testing whether the draw corresponding to the token
+ * has been flushed. If it has not been flushed then the batch must perform an inline upload
+ * instead. When scheduling an inline upload the batch provides the token of the draw that the
+ * upload must occur before. The upload will then occur between the draw that requires the new
+ * data but after the token that requires the old data.
+ *
+ * TODO: Currently the token/upload interface is spread over GrDrawBatch, GrVertexBatch,
+ * GrDrawBatch::Target, and GrVertexBatch::Target. However, the interface at the GrDrawBatch
+ * level is not complete and isn't useful. We should push it down to GrVertexBatch until it
+ * is required at the GrDrawBatch level.
+ */
+ 
+/**
  * GrDrawBatch instances use this object to allocate space for their geometry and to issue the draws
  * that render their batch.
  */
 class GrDrawBatch::Target {
 public:
     Target(GrBatchFlushState* state, GrDrawBatch* batch) : fState(state), fBatch(batch) {}
 
-    void upload(GrBatchUploader* upload) {
-        if (this->asapToken() == upload->lastUploadToken()) {
-            fState->addASAPUpload(upload);
-        } else {
-            fBatch->fInlineUploads.push_back().reset(SkRef(upload));
-        }
+    /** Returns the token of the draw that this upload will occur before. */
+    GrBatchDrawToken addInlineUpload(DeferredUploadFn&& upload) {
+        fBatch->fInlineUploads.emplace_back(std::move(upload), fState->nextDrawToken());
+        return fBatch->fInlineUploads.back().fUploadBeforeToken;
     }
 
-    bool hasTokenBeenFlushed(GrBatchToken token) const {
-        return fState->hasTokenBeenFlushed(token);
+    /** Returns the token of the draw that this upload will occur before. Since ASAP uploads
+        are done first during a flush, this will be the first token since the most recent
+        flush. */
+    GrBatchDrawToken addAsapUpload(DeferredUploadFn&& upload) {
+        fState->addASAPUpload(std::move(upload));
+        return fState->nextTokenToFlush();
     }
-    GrBatchToken currentToken() const { return fState->currentToken(); }
-    GrBatchToken asapToken() const { return fState->asapToken(); }
+
+    bool hasDrawBeenFlushed(GrBatchDrawToken token) const {
+        return fState->hasDrawBeenFlushed(token);
+    }
+
+    /** Gets the next draw token that will be issued by this target. This can be used by a batch
+        to record that the next draw it issues will use a resource (e.g. texture) while preparing
+        that draw. */
+    GrBatchDrawToken nextDrawToken() const { return fState->nextDrawToken(); }
 
     const GrCaps& caps() const { return fState->caps(); }
 
     GrResourceProvider* resourceProvider() const { return fState->resourceProvider(); }
 
 protected:
     GrDrawBatch* batch() { return fBatch; }
     GrBatchFlushState* state() { return fState; }
 
 private:
     GrBatchFlushState*  fState;
     GrDrawBatch*        fBatch;
 };
 
 /** Extension of GrDrawBatch::Target for use by GrVertexBatch. Adds the ability to create vertex
     draws. */
 class GrVertexBatch::Target : public GrDrawBatch::Target {
 public:
     Target(GrBatchFlushState* state, GrVertexBatch* batch) : INHERITED(state, batch) {}
 
-    void initDraw(const GrPrimitiveProcessor* primProc) {
-        GrVertexBatch::DrawArray* draws = this->vertexBatch()->fDrawArrays.addToTail();
-        draws->fPrimitiveProcessor.reset(primProc);
-        this->state()->advanceToken();
-    }
-
-    void draw(const GrMesh& mesh) {
-        this->vertexBatch()->fDrawArrays.tail()->fDraws.push_back(mesh);
-    }
+    void draw(const GrGeometryProcessor* gp, const GrMesh& mesh);
 
     void* makeVertexSpace(size_t vertexSize, int vertexCount,
                           const GrBuffer** buffer, int* startVertex) {
         return this->state()->makeVertexSpace(vertexSize, vertexCount, buffer, startVertex);
     }
 
     uint16_t* makeIndexSpace(int indexCount, const GrBuffer** buffer, int* startIndex) {
         return this->state()->makeIndexSpace(indexCount, buffer, startIndex);
     }
 
     /** Helpers for batches which over-allocate and then return data to the pool. */
     void putBackIndices(int indices) { this->state()->putBackIndices(indices); }
     void putBackVertices(int vertices, size_t vertexStride) {
         this->state()->putBackVertexSpace(vertices * vertexStride);
     }
 
 private:
     GrVertexBatch* vertexBatch() { return static_cast<GrVertexBatch*>(this->batch()); }
     typedef GrDrawBatch::Target INHERITED;
 };
 
 #endif