Simplify path allocation, clean up resources correctly

src/gpu/gl/GrGLPathRendering.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "gl/GrGLPathRendering.h"
-#include "gl/GrGLNameAllocator.h"
 #include "gl/GrGLUtil.h"
 #include "gl/GrGLGpu.h"
 
 #include "GrGLPath.h"
 #include "GrGLPathRange.h"
 #include "GrGLPathRendering.h"
 
 #include "SkStream.h"
 #include "SkTypeface.h"
 
 #define GL_CALL(X) GR_GL_CALL(this->gpu()->glInterface(), X)
 #define GL_CALL_RET(RET, X) GR_GL_CALL_RET(this->gpu()->glInterface(), RET, X)
 
+// Number of paths to allocate per glGenPaths call. The call can be overly slow on command buffer GL
+// implementation. The call has a result value, and thus waiting for the call completion is needed.
+static const GrGLsizei kPathIDPreallocationAmount = 65536;
 
 static const GrGLenum gIndexType2GLType[] = {
     GR_GL_UNSIGNED_BYTE,
     GR_GL_UNSIGNED_SHORT,
     GR_GL_UNSIGNED_INT
 };
 
 GR_STATIC_ASSERT(0 == GrPathRange::kU8_PathIndexType);
 GR_STATIC_ASSERT(1 == GrPathRange::kU16_PathIndexType);
 GR_STATIC_ASSERT(2 == GrPathRange::kU32_PathIndexType);
@@ skipping 20 matching lines @@
             SkFAIL("Unexpected path fill.");
             /* fallthrough */;
         case kIncClamp_StencilOp:
             return GR_GL_COUNT_UP;
         case kInvert_StencilOp:
             return GR_GL_INVERT;
     }
 }
 
 GrGLPathRendering::GrGLPathRendering(GrGLGpu* gpu)
-    : GrPathRendering(gpu) {
+    : GrPathRendering(gpu)
+    , fPreallocatedPathCount(0) {
     const GrGLInterface* glInterface = gpu->glInterface();
     fCaps.bindFragmentInputSupport =
         nullptr != glInterface->fFunctions.fBindFragmentInputLocation;
 }
 
 GrGLPathRendering::~GrGLPathRendering() {
+    if (fPreallocatedPathCount > 0) {
+        this->deletePaths(fFirstPreallocatedPathID, fPreallocatedPathCount);
+    }
 }
 
 void GrGLPathRendering::abandonGpuResources() {
-    fPathNameAllocator.reset(nullptr);
+    fPreallocatedPathCount = 0;
 }
 
 void GrGLPathRendering::resetContext() {
     fHWProjectionMatrixState.invalidate();
     // we don't use the model view matrix.
     GL_CALL(MatrixLoadIdentity(GR_GL_PATH_MODELVIEW));
 
     fHWPathStencilSettings.invalidate();
 }
 
@@ skipping 139 matching lines @@
     fHWProjectionMatrixState.fViewMatrix = matrix;
     fHWProjectionMatrixState.fRenderTargetSize = renderTargetSize;
     fHWProjectionMatrixState.fRenderTargetOrigin = renderTargetOrigin;
 
     float glMatrix[4 * 4];
     fHWProjectionMatrixState.getRTAdjustedGLMatrix<4>(glMatrix);
     GL_CALL(MatrixLoadf(GR_GL_PATH_PROJECTION, glMatrix));
 }
 
 GrGLuint GrGLPathRendering::genPaths(GrGLsizei range) {
-    if (range > 1) {
-        GrGLuint name;
-        GL_CALL_RET(name, GenPaths(range));
-        return name;
+    SkASSERT(range > 0);
+    GrGLuint firstID;
+    if (fPreallocatedPathCount >= range) {
+        firstID = fFirstPreallocatedPathID;
+        fPreallocatedPathCount -= range;
+        fFirstPreallocatedPathID += range;
+        return firstID;
+    }
+    // Allocate range + the amount to fill up preallocation amount. If succeed, either join with
+    // the existing preallocation range or delete the existing and use the new (potentially partial)
+    // preallocation range.
+    GrGLsizei allocAmount = range + (kPathIDPreallocationAmount - fPreallocatedPathCount);
+    if (allocAmount >= range) {
+        GL_CALL_RET(firstID, GenPaths(allocAmount));
+
+        if (firstID != 0) {
+            if (fPreallocatedPathCount > 0 &&
+                firstID == fFirstPreallocatedPathID + fPreallocatedPathCount) {
+                firstID = fFirstPreallocatedPathID;
+                fPreallocatedPathCount += allocAmount - range;
+                fFirstPreallocatedPathID += range;
+                return firstID;
+            }
+
+            if (allocAmount > range) {
+                if (fPreallocatedPathCount > 0) {
+                    this->deletePaths(fFirstPreallocatedPathID, fPreallocatedPathCount);
+                }
+                fFirstPreallocatedPathID = firstID + range;
+                fPreallocatedPathCount = allocAmount - range;
+            }
+            // Special case: if allocAmount == range, we have full preallocated range.
+            return firstID;
+        }
+    }
+    // Failed to allocate with preallocation. Remove existing preallocation and try to allocate just
+    // the range.
+    if (fPreallocatedPathCount > 0) {
+        this->deletePaths(fFirstPreallocatedPathID, fPreallocatedPathCount);
+        fPreallocatedPathCount = 0;
     }
 
-    if (nullptr == fPathNameAllocator.get()) {
-        static const int range = 65536;
-        GrGLuint firstName;
-        GL_CALL_RET(firstName, GenPaths(range));
-        fPathNameAllocator.reset(new GrGLNameAllocator(firstName, firstName + range));
+    GL_CALL_RET(firstID, GenPaths(range));
+    if (firstID == 0) {
+        SkDebugf("Warning: Failed to allocate path\n");
     }
-
-    // When allocating names one at a time, pull from a client-side pool of
-    // available names in order to save a round trip to the GL server.
-    GrGLuint name = fPathNameAllocator->allocateName();
-
-    if (0 == name) {
-        // Our reserved path names are all in use. Fall back on GenPaths.
-        GL_CALL_RET(name, GenPaths(1));
-    }
-
-    return name;
+    return firstID;
 }
 
 void GrGLPathRendering::deletePaths(GrGLuint path, GrGLsizei range) {
-    if (range > 1) {
-        // It is not supported to delete names in ranges that were allocated
-        // individually using GrGLPathNameAllocator.
-        SkASSERT(nullptr == fPathNameAllocator.get() ||
-                 path + range <= fPathNameAllocator->firstName() ||
-                 path >= fPathNameAllocator->endName());
-        GL_CALL(DeletePaths(path, range));
-        return;
-    }
-
-    if (nullptr == fPathNameAllocator.get() ||
-        path < fPathNameAllocator->firstName() ||
-        path >= fPathNameAllocator->endName()) {
-        // If we aren't inside fPathNameAllocator's range then this name was
-        // generated by the GenPaths fallback (or else was never allocated).
-        GL_CALL(DeletePaths(path, 1));
-        return;
-    }
-
-    // Make the path empty to save memory, but don't free the name in the driver.
-    GL_CALL(PathCommands(path, 0, nullptr, 0, GR_GL_FLOAT, nullptr));
-    fPathNameAllocator->free(path);
+    GL_CALL(DeletePaths(path, range));
 }
 
 void GrGLPathRendering::flushPathStencilSettings(const GrStencilSettings& stencilSettings) {
     if (fHWPathStencilSettings != stencilSettings) {
         // Just the func, ref, and mask is set here. The op and write mask are params to the call
         // that draws the path to the SB (glStencilFillPath)
         GrGLenum func =
             GrToGLStencilFunc(stencilSettings.func(GrStencilSettings::kFront_Face));
         GL_CALL(PathStencilFunc(func, stencilSettings.funcRef(GrStencilSettings::kFront_Face),
                                 stencilSettings.funcMask(GrStencilSettings::kFront_Face)));
 
         fHWPathStencilSettings = stencilSettings;
     }
 }
 
 inline GrGLGpu* GrGLPathRendering::gpu() {
     return static_cast<GrGLGpu*>(fGpu);
 }