Adaptively throttle texture uploads

cc/CCTextureUpdateController.cpp

 // Copyright 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 
 #include "CCTextureUpdateController.h"
 
 #include "GraphicsContext3D.h"
 #include "TextureCopier.h"
 #include "TextureUploader.h"
+#include "TraceEvent.h"
+#include <limits>
 #include <wtf/CurrentTime.h>
 
 namespace {
 
-// Number of textures to update with each call to updateMoreTexturesIfEnoughTimeRemaining().
-static const size_t textureUpdatesPerTick = 12;
+static const size_t pixelsPerTexture = 256 * 256;
+
+// Minimum number of textures to update with each call to updateMoreTexturesIfEnoughTimeRemaining().
+static const size_t textureUpdatesPerFullTickMin = 12;
 
 // Measured in seconds.
 static const double textureUpdateTickRate = 0.004;
 
 // Measured in seconds.
 static const double uploaderBusyTickRate = 0.001;
 
 // Flush interval when performing texture uploads.
 static const int textureUploadFlushPeriod = 4;
 
 } // anonymous namespace
 
 namespace cc {
 
-size_t CCTextureUpdateController::maxPartialTextureUpdates()
+size_t CCTextureUpdateController::maxPartialUpdatesDefault()
 {
-    return textureUpdatesPerTick;
+    return textureUpdatesPerFullTickMin;
+}
+
+size_t CCTextureUpdateController::maxPartialUpdates(TextureUploader* uploader)
+{
+    return maxFullUpdatesPerTick(uploader);
+}
+
+size_t CCTextureUpdateController::maxFullUpdatesPerTick(TextureUploader* uploader)
+{
+    double texturesPerSecond = uploader->estimatedPixelsPerSecond() / pixelsPerTexture;
+
+    return std::max(textureUpdatesPerFullTickMin,
+                    (size_t) floor(textureUpdateTickRate * texturesPerSecond));
 }
 
 void CCTextureUpdateController::updateTextures(CCResourceProvider* resourceProvider, TextureCopier* copier, TextureUploader* uploader, CCTextureUpdateQueue* queue, size_t count)

[brianderson, 2012/09/18 00:45:52]

The previous patch set had a few bugs that caused back to back flushes, so I
needed to reorganize the logic again.

 {
+    TRACE_EVENT0("cc", "CCTextureUpdateController::updateTextures");
     if (queue->fullUploadSize() || queue->partialUploadSize()) {
         if (uploader->isBusy())
             return;
 
         uploader->beginUploads();
 
         size_t fullUploadCount = 0;
-        while (queue->fullUploadSize() && fullUploadCount < count) {
-            uploader->uploadTexture(resourceProvider, queue->takeFirstFullUpload());
-            fullUploadCount++;
-            if (!(fullUploadCount % textureUploadFlushPeriod))
+        if (queue->fullUploadSize()) {
+            while (queue->fullUploadSize() && fullUploadCount < count) {
+                if (!(fullUploadCount % textureUploadFlushPeriod) && fullUploadCount)
+                    resourceProvider->shallowFlushIfSupported();
+                uploader->uploadTexture(resourceProvider, queue->takeFirstFullUpload());
+                fullUploadCount++;
+            }
+
+            bool cantUpdloadAllPartials = (count - fullUploadCount) < queue->partialUploadSize();
+            if (cantUpdloadAllPartials) {
+                uploader->endUploads();
                 resourceProvider->shallowFlushIfSupported();
+                return;
+            }
         }
 
-        // Make sure there are no dangling uploads without a flush.
-        if (fullUploadCount % textureUploadFlushPeriod)
-            resourceProvider->shallowFlushIfSupported();
+        ASSERT(queue->partialUploadSize() <= (count - fullUploadCount));
 
-        bool moreUploads = queue->fullUploadSize();
-
-        ASSERT(queue->partialUploadSize() <= count);
-        // We need another update batch if the number of updates remaining
-        // in |count| is greater than the remaining partial entries.
-        if ((count - fullUploadCount) < queue->partialUploadSize())
-            moreUploads = true;
-
-        if (moreUploads) {
-            uploader->endUploads();
-            return;
+        size_t partialUploadCount = 0;
+        if (queue->partialUploadSize()) {
+            if (fullUploadCount)
+                resourceProvider->shallowFlushIfSupported();
+            while (queue->partialUploadSize()) {
+                if (!(partialUploadCount % textureUploadFlushPeriod) && partialUploadCount)
+                    resourceProvider->shallowFlushIfSupported();
+                uploader->uploadTexture(resourceProvider, queue->takeFirstPartialUpload());
+                partialUploadCount++;
+            }
         }
 
-        size_t partialUploadCount = 0;
-        while (queue->partialUploadSize()) {
-            uploader->uploadTexture(resourceProvider, queue->takeFirstPartialUpload());
-            partialUploadCount++;
-            if (!(partialUploadCount % textureUploadFlushPeriod))
-                resourceProvider->shallowFlushIfSupported();
-        }
-
-        // Make sure there are no dangling partial uploads without a flush.
-        if (partialUploadCount % textureUploadFlushPeriod)
-            resourceProvider->shallowFlushIfSupported();
-
         uploader->endUploads();
+        resourceProvider->shallowFlushIfSupported();
     }
 
     size_t copyCount = 0;
     while (queue->copySize()) {
         copier->copyTexture(queue->takeFirstCopy());
         copyCount++;
     }
 
     // If we've performed any texture copies, we need to insert a flush here into the compositor context
     // before letting the main thread proceed as it may make draw calls to the source texture of one of
     // our copy operations.
     if (copyCount)
         copier->flush();
 }
 
-CCTextureUpdateController::CCTextureUpdateController(CCTextureUpdateControllerClient* client, CCThread* thread, PassOwnPtr<CCTextureUpdateQueue> queue, CCResourceProvider* resourceProvider, TextureCopier* copier, TextureUploader* uploader)
+CCTextureUpdateController::CCTextureUpdateController(CCTextureUpdateControllerClient* client, CCThread* thread, PassOwnPtr<CCTextureUpdateQueue> queue, CCResourceProvider* resourceProvider, TextureCopier* copier, TextureUploader* uploader, size_t maxPartialTextureUpdates)
     : m_client(client)
     , m_timer(adoptPtr(new CCTimer(thread, this)))
     , m_queue(queue)
     , m_resourceProvider(resourceProvider)
     , m_copier(copier)
     , m_uploader(uploader)
     , m_monotonicTimeLimit(0)
+    , m_textureUpdatesPerTick(maxFullUpdatesPerTick(uploader))
+    , m_maxPartialTextureUpdates(maxPartialTextureUpdates)
     , m_firstUpdateAttempt(true)
 {
 }
 
 CCTextureUpdateController::~CCTextureUpdateController()
 {
 }
 
 void CCTextureUpdateController::performMoreUpdates(
     double monotonicTimeLimit)
@@ skipping 37 matching lines @@
     return monotonicallyIncreasingTime();
 }
 
 double CCTextureUpdateController::updateMoreTexturesTime() const
 {
     return textureUpdateTickRate;
 }
 
 size_t CCTextureUpdateController::updateMoreTexturesSize() const
 {
-    return textureUpdatesPerTick;
+    if (m_queue->fullUploadSize() && !m_queue->partialUploadSize())
+        return m_maxPartialTextureUpdates;
+    return m_textureUpdatesPerTick;
 }
 
 bool CCTextureUpdateController::updateMoreTexturesIfEnoughTimeRemaining()
 {
     // Uploader might be busy when we're too aggressive in our upload time
     // estimate. We use a different timeout here to prevent unnecessary
     // amounts of idle time.
     if (m_uploader->isBusy()) {
         m_timer->startOneShot(uploaderBusyTickRate);
         return true;
@@ skipping 31 matching lines @@
     }
 
     // Make sure there are no dangling partial uploads without a flush.
     if (uploadCount % textureUploadFlushPeriod)
         m_resourceProvider->shallowFlushIfSupported();
 
     m_uploader->endUploads();
 }
 
 }