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;
 
 // Flush interval when performing texture uploads.
 static const int textureUploadFlushPeriod = 4;
 
 } // anonymous namespace
 
 namespace WebCore {
 
-size_t CCTextureUpdateController::maxPartialTextureUpdates()
+size_t CCTextureUpdateController::maxTextureUpdatesDefault()
 {
-    return textureUpdatesPerTick;
+    return textureUpdatesPerFullTickMin;
+}
+
+size_t CCTextureUpdateController::maxTextureUpdates(TextureUploader* uploader)
+{
+    double texturesPerSecond = uploader->estimatedPixelsPerSecond() / pixelsPerTexture;
+
+    return std::max(textureUpdatesPerFullTickMin,
+                    (size_t) floor(textureUpdateTickRate * texturesPerSecond));
+}
+
+PassOwnPtr<CCTextureUpdateController> CCTextureUpdateController::create(CCThread* thread, PassOwnPtr<CCTextureUpdateQueue> queue, CCResourceProvider* resourceProvider, TextureCopier* copier, TextureUploader* uploader, size_t maxTextureUpdates)
+{
+    return adoptPtr(new CCTextureUpdateController(thread, queue, resourceProvider, copier, uploader, maxTextureUpdates));
 }
 
 void CCTextureUpdateController::updateTextures(CCResourceProvider* resourceProvider, TextureCopier* copier, TextureUploader* uploader, CCTextureUpdateQueue* queue, size_t count)
 {
     if (queue->fullUploadSize() || queue->partialUploadSize()) {
         if (uploader->isBusy())
             return;
 
         uploader->beginUploads();
 
         size_t fullUploadCount = 0;
-        while (queue->fullUploadSize() && fullUploadCount < count) {
+        bool uploadMore = queue->fullUploadSize() && fullUploadCount < count;
+        while (uploadMore) {
             uploader->uploadTexture(resourceProvider, queue->takeFirstFullUpload());
             fullUploadCount++;
-            if (!(fullUploadCount % textureUploadFlushPeriod))
+            uploadMore = queue->fullUploadSize() && fullUploadCount < count;
+
+            // Flush periodically, but deffer our last flush until after uploader->endUploads()
+            // in order to keep the query associated with endUploads grouped with our last texture upload.
+            if (!(fullUploadCount % textureUploadFlushPeriod) && uploadMore)
                 resourceProvider->shallowFlushIfSupported();
         }
 
-        // Make sure there are no dangling uploads without a flush.
-        if (fullUploadCount % textureUploadFlushPeriod)
+        ASSERT(queue->partialUploadSize() <= count);
+        bool needAnotherTick = queue->fullUploadSize() || ((count - fullUploadCount) < queue->partialUploadSize());
+        if (needAnotherTick) {
+            uploader->endUploads();
             resourceProvider->shallowFlushIfSupported();
-
-        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;
         }
+        resourceProvider->shallowFlushIfSupported();
 
         size_t partialUploadCount = 0;
         while (queue->partialUploadSize()) {
             uploader->uploadTexture(resourceProvider, queue->takeFirstPartialUpload());

[nduca, 2012/09/14 05:50:26]

I think we should do partials all at once, and swamp the GPU if we want. And, we
should just set max partials conservatively. To like, 8. Its my suspicion that
partials come very infrequently, in twos or threes, not huge vast numbers...
and, though I might be wrong, I'd rather we do this just for the non partials
case first, then come back to the other when we've got data in hand. Wdyt?

[brianderson, 2012/09/14 19:12:00]

Do you mean we should not upload fulls and partials in the same tick?

             partialUploadCount++;
-            if (!(partialUploadCount % textureUploadFlushPeriod))
+            
+            // Flush periodically, but deffer our last flush until after uploader->endUploads()

[nduca, 2012/09/14 05:50:26]

deffer->defer

[brianderson, 2012/09/14 19:12:00]

ok

+            // in order to keep the query associated with endUploads grouped with our last texture upload.
+            if (!(partialUploadCount % textureUploadFlushPeriod) && queue->partialUploadSize())
                 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(CCThread* thread, PassOwnPtr<CCTextureUpdateQueue> queue, CCResourceProvider* resourceProvider, TextureCopier* copier, TextureUploader* uploader)
+CCTextureUpdateController::CCTextureUpdateController(CCThread* thread, PassOwnPtr<CCTextureUpdateQueue> queue, CCResourceProvider* resourceProvider, TextureCopier* copier, TextureUploader* uploader, size_t maxTextureUpdates)
     : m_timer(adoptPtr(new CCTimer(thread, this)))
     , m_queue(queue)
     , m_resourceProvider(resourceProvider)
     , m_copier(copier)
     , m_uploader(uploader)
     , m_monotonicTimeLimit(0)
+    , m_textureUpdatesPerTick(maxTextureUpdates)
     , m_firstUpdateAttempt(true)
 {
 }
 
 CCTextureUpdateController::~CCTextureUpdateController()
 {
 }
 
 bool CCTextureUpdateController::hasMoreUpdates() const
 {
@@ skipping 30 matching lines @@
     return monotonicallyIncreasingTime();
 }
 
 double CCTextureUpdateController::updateMoreTexturesTime() const
 {
     return textureUpdateTickRate;
 }
 
 size_t CCTextureUpdateController::updateMoreTexturesSize() const
 {
-    return textureUpdatesPerTick;
+    return m_textureUpdatesPerTick;
 }
 
 void CCTextureUpdateController::updateMoreTexturesIfEnoughTimeRemaining()
 {
     bool hasTimeRemaining = monotonicTimeNow() < m_monotonicTimeLimit - updateMoreTexturesTime();
     if (hasTimeRemaining)
         updateMoreTexturesNow();
 }
 
 void CCTextureUpdateController::updateMoreTexturesNow()
 {
     m_timer->startOneShot(updateMoreTexturesTime());
     updateTextures(m_resourceProvider, m_copier, m_uploader, m_queue.get(), updateMoreTexturesSize());
 }
 
 }