Add trace event when GrBufferAllocPool unmaps a buffer indicating what % of the buffer was unwritte…

src/gpu/GrBufferAllocPool.cpp

 
 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "GrBufferAllocPool.h"
 #include "GrDrawTargetCaps.h"
 #include "GrGpu.h"
 #include "GrIndexBuffer.h"
 #include "GrTypes.h"
 #include "GrVertexBuffer.h"
 
+#include "SkTraceEvent.h"
+
 #ifdef SK_DEBUG
     #define VALIDATE validate
 #else
     static void VALIDATE(bool = false) {}
 #endif
 
 // page size
 #define GrBufferAllocPool_MIN_BLOCK_SIZE ((size_t)1 << 12)
 
+#define UNMAP_BUFFER(block)                                                               \
+do {                                                                                      \
+    TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("skia.gpu"),                           \
+                         "GrBufferAllocPool Unmapping Buffer",                            \
+                         TRACE_EVENT_SCOPE_THREAD,                                        \
+                         "percent_unwritten",                                             \
+                         (float)((block).fBytesFree) / (block).fBuffer->gpuMemorySize()); \
+    (block).fBuffer->unmap();                                                             \
+} while (false)
+
 GrBufferAllocPool::GrBufferAllocPool(GrGpu* gpu,
                                      BufferType bufferType,
                                      bool frequentResetHint,
                                      size_t blockSize,
                                      int preallocBufferCnt) :
         fBlocks(SkTMax(8, 2*preallocBufferCnt)) {
 
     SkASSERT(NULL != gpu);
     fGpu = gpu;
     fGpu->ref();
@@ skipping 14 matching lines @@
             *fPreallocBuffers.append() = buffer;
         }
     }
 }
 
 GrBufferAllocPool::~GrBufferAllocPool() {
     VALIDATE();
     if (fBlocks.count()) {
         GrGeometryBuffer* buffer = fBlocks.back().fBuffer;
         if (buffer->isMapped()) {
-            buffer->unmap();
+            UNMAP_BUFFER(fBlocks.back());
         }
     }
     while (!fBlocks.empty()) {
         destroyBlock();
     }
     fPreallocBuffers.unrefAll();
     releaseGpuRef();
 }
 
 void GrBufferAllocPool::releaseGpuRef() {
     if (fGpuIsReffed) {
         fGpu->unref();
         fGpuIsReffed = false;
     }
 }
 
 void GrBufferAllocPool::reset() {
     VALIDATE();
     fBytesInUse = 0;
     if (fBlocks.count()) {
         GrGeometryBuffer* buffer = fBlocks.back().fBuffer;
         if (buffer->isMapped()) {
-            buffer->unmap();
+            UNMAP_BUFFER(fBlocks.back());
         }
     }
     // fPreallocBuffersInUse will be decremented down to zero in the while loop
     int preallocBuffersInUse = fPreallocBuffersInUse;
     while (!fBlocks.empty()) {
         this->destroyBlock();
     }
     if (fPreallocBuffers.count()) {
         // must set this after above loop.
         fPreallocBufferStartIdx = (fPreallocBufferStartIdx +
                                    preallocBuffersInUse) %
                                   fPreallocBuffers.count();
     }
     // we may have created a large cpu mirror of a large VB. Reset the size
     // to match our pre-allocated VBs.
     fCpuData.reset(fMinBlockSize);
     SkASSERT(0 == fPreallocBuffersInUse);
     VALIDATE();
 }
 
 void GrBufferAllocPool::unmap() {
     VALIDATE();
 
     if (NULL != fBufferPtr) {
         BufferBlock& block = fBlocks.back();
         if (block.fBuffer->isMapped()) {
-            block.fBuffer->unmap();
+            UNMAP_BUFFER(block);
         } else {
             size_t flushSize = block.fBuffer->gpuMemorySize() - block.fBytesFree;
-            this->flushCpuData(fBlocks.back().fBuffer, flushSize);
+            this->flushCpuData(fBlocks.back(), flushSize);
         }
         fBufferPtr = NULL;
     }
     VALIDATE();
 }
 
 #ifdef SK_DEBUG
 void GrBufferAllocPool::validate(bool unusedBlockAllowed) const {
     if (NULL != fBufferPtr) {
         SkASSERT(!fBlocks.empty());
@@ skipping 107 matching lines @@
         // caller shouldnt try to put back more than they've taken
         SkASSERT(!fBlocks.empty());
         BufferBlock& block = fBlocks.back();
         size_t bytesUsed = block.fBuffer->gpuMemorySize() - block.fBytesFree;
         if (bytes >= bytesUsed) {
             bytes -= bytesUsed;
             fBytesInUse -= bytesUsed;
             // if we locked a vb to satisfy the make space and we're releasing
             // beyond it, then unmap it.
             if (block.fBuffer->isMapped()) {
-                block.fBuffer->unmap();
+                UNMAP_BUFFER(block);
             }
             this->destroyBlock();
         } else {
             block.fBytesFree += bytes;
             fBytesInUse -= bytes;
             bytes = 0;
             break;
         }
     }
     if (!fPreallocBuffersInUse && fPreallocBuffers.count()) {
@@ skipping 28 matching lines @@
             fBlocks.pop_back();
             return false;
         }
     }
 
     block.fBytesFree = size;
     if (NULL != fBufferPtr) {
         SkASSERT(fBlocks.count() > 1);
         BufferBlock& prev = fBlocks.fromBack(1);
         if (prev.fBuffer->isMapped()) {
-            prev.fBuffer->unmap();
+            UNMAP_BUFFER(prev);
         } else {
-            flushCpuData(prev.fBuffer,
-                         prev.fBuffer->gpuMemorySize() - prev.fBytesFree);
+            this->flushCpuData(prev, prev.fBuffer->gpuMemorySize() - prev.fBytesFree);
         }
         fBufferPtr = NULL;
     }
 
     SkASSERT(NULL == fBufferPtr);
 
     // If the buffer is CPU-backed we map it because it is free to do so and saves a copy.
     // Otherwise when buffer mapping is supported:
     //      a) If the frequently reset hint is set we only map when the requested size meets a
     //      threshold (since we don't expect it is likely that we will see more vertex data)
@@ skipping 32 matching lines @@
         if (block.fBuffer == fPreallocBuffers[prevPreallocBuffer]) {
             --fPreallocBuffersInUse;
         }
     }
     SkASSERT(!block.fBuffer->isMapped());
     block.fBuffer->unref();
     fBlocks.pop_back();
     fBufferPtr = NULL;
 }
 
-void GrBufferAllocPool::flushCpuData(GrGeometryBuffer* buffer,
-                                     size_t flushSize) {
+void GrBufferAllocPool::flushCpuData(const BufferBlock& block, size_t flushSize) {
+    GrGeometryBuffer* buffer = block.fBuffer;
     SkASSERT(NULL != buffer);
     SkASSERT(!buffer->isMapped());
     SkASSERT(fCpuData.get() == fBufferPtr);
     SkASSERT(flushSize <= buffer->gpuMemorySize());
     VALIDATE(true);
 
     if (GrDrawTargetCaps::kNone_MapFlags != fGpu->caps()->mapBufferFlags() &&
         flushSize > GR_GEOM_BUFFER_MAP_THRESHOLD) {
         void* data = buffer->map();
         if (NULL != data) {
             memcpy(data, fBufferPtr, flushSize);
-            buffer->unmap();
+            UNMAP_BUFFER(block);
             return;
         }
     }
     buffer->updateData(fBufferPtr, flushSize);
     VALIDATE(true);
 }
 
 GrGeometryBuffer* GrBufferAllocPool::createBuffer(size_t size) {
     if (kIndex_BufferType == fBufferType) {
         return fGpu->createIndexBuffer(size, true);
@@ skipping 109 matching lines @@
     }
 }
 
 int GrIndexBufferAllocPool::preallocatedBufferIndices() const {
     return static_cast<int>(INHERITED::preallocatedBufferSize() / sizeof(uint16_t));
 }
 
 int GrIndexBufferAllocPool::currentBufferIndices() const {
     return currentBufferItems(sizeof(uint16_t));
 }