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;
+// Number of partial updates we allow.
+static const size_t maxPartialTextures = 12;

[reveman, 2012/09/18 20:34:18]

maybe partialTextureUpdatesCount or partialTextureUpdatesMax instead?

[brianderson, 2012/09/18 21:09:31]

Going with partialTextureUpdatesMax.

 
 // 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()
 {
-    return textureUpdatesPerTick;
+    return maxPartialTextures;
+}
+
+size_t CCTextureUpdateController::maxFullUpdatesPerTick(TextureUploader* uploader)
+{
+    double texturesPerSecond = uploader->estimatedTexturesPerSecond();
+    size_t texturesPerTick = floor(textureUpdateTickRate * texturesPerSecond);
+    return std::max(static_cast<size_t>(1), texturesPerTick);

[reveman, 2012/09/18 20:34:18]

you can get rid of the static_cast now, right?

[brianderson, 2012/09/18 21:09:31]

There's a compile error without the static_cast, so it has to stay ugly.
Alternatively, I could use the following, but I don't think it's as clear as
using max():
return texturesPerTick ? texturesPerTick : 1;

[jamesr, 2012/09/18 21:13:00]

is "1u" as the first parameter enough to escape the ugly?

[brianderson, 2012/09/18 21:15:14]

Nope, but 1LU is.

 }
 
 void CCTextureUpdateController::updateTextures(CCResourceProvider* resourceProvider, TextureUploader* uploader, CCTextureUpdateQueue* queue)
 {
     size_t uploadCount = 0;
     while (queue->fullUploadSize()) {
         if (!(uploadCount % textureUploadFlushPeriod) && uploadCount)
             resourceProvider->shallowFlushIfSupported();
 
         uploader->uploadTexture(
@@ skipping 26 matching lines @@
     }
 }
 
 CCTextureUpdateController::CCTextureUpdateController(CCTextureUpdateControllerClient* client, CCThread* thread, PassOwnPtr<CCTextureUpdateQueue> queue, CCResourceProvider* resourceProvider, TextureUploader* uploader)
     : m_client(client)
     , m_timer(adoptPtr(new CCTimer(thread, this)))
     , m_queue(queue)
     , m_resourceProvider(resourceProvider)
     , m_uploader(uploader)
     , m_monotonicTimeLimit(0)
+    , m_textureUpdatesPerTick(maxFullUpdatesPerTick(uploader))
     , m_firstUpdateAttempt(true)
 {
 }
 
 CCTextureUpdateController::~CCTextureUpdateController()
 {
 }
 
 void CCTextureUpdateController::performMoreUpdates(
     double monotonicTimeLimit)
@@ skipping 35 matching lines @@
     return monotonicallyIncreasingTime();
 }
 
 double CCTextureUpdateController::updateMoreTexturesTime() const
 {
     return textureUpdateTickRate;
 }
 
 size_t CCTextureUpdateController::updateMoreTexturesSize() const
 {
-    return textureUpdatesPerTick;
+    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 12 matching lines @@
 void CCTextureUpdateController::updateMoreTexturesNow()
 {
     size_t uploads = std::min(
         m_queue->fullUploadSize(), updateMoreTexturesSize());
     m_timer->startOneShot(
         updateMoreTexturesTime() / updateMoreTexturesSize() * uploads);
 
     if (!uploads)
         return;
 
+    size_t uploadCount = 0;
     m_uploader->beginUploads();
-
-    size_t uploadCount = 0;
-    while (uploads--) {
-        m_uploader->uploadTexture(
-            m_resourceProvider, m_queue->takeFirstFullUpload());
+    while (m_queue->fullUploadSize() && uploadCount < uploads) {
+        if (!(uploadCount % textureUploadFlushPeriod) && uploadCount)
+            m_resourceProvider->shallowFlushIfSupported();
+        m_uploader->uploadTexture(m_resourceProvider, m_queue->takeFirstFullUpload());
         uploadCount++;
-        if (!(uploadCount % textureUploadFlushPeriod))
-            m_resourceProvider->shallowFlushIfSupported();
     }
-
-    // Make sure there are no dangling partial uploads without a flush.
-    if (uploadCount % textureUploadFlushPeriod)
-        m_resourceProvider->shallowFlushIfSupported();
-
     m_uploader->endUploads();
+    m_resourceProvider->shallowFlushIfSupported();
 }
 
 }