Adaptively throttle texture uploads

cc/ThrottledTextureUploader.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 "ThrottledTextureUploader.h"
 
 #include "Extensions3DChromium.h"
+#include <algorithm>
 #include <public/WebGraphicsContext3D.h>
 
 namespace {
 
 // Number of pending texture update queries to allow.
 static const size_t maxPendingQueries = 2;
 
+// How many previous uploads to use when predicting future throughput.
+static const size_t uploadHistorySize = 10;

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

This is in number of queries, right? I might make this be bigger, like 50 or
100, or even longer. The whole system can destabilize during big transitions, 
or when you've opened a background page... so having a big history is maybe
helpful?

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

I intentionally kept it low so that we would quickly adapt to any short-term
bumps. The thinking being that we'd want to back off on texture uploads under
high load to keep animations smooth.

+
+// Default number of pixels per second.

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

This seems a bit low, no? If you have 1.5ms per texture as it seems to be on
CrOS now, then thats like 666 textures per second. Each texture is 65536 pixels
in this metric. So um... math fails me.

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

It is low.  What I've calculated below is actually pixels per 16ms.  (48 came
from 12 textures per 4ms.)  Will fix.

+static double estimatedPixelsPerSecondDefault = 256 * 256 * 48;
+
 } // anonymous namespace
 
 namespace WebCore {
 
 ThrottledTextureUploader::Query::Query(WebKit::WebGraphicsContext3D* context)
     : m_context(context)
     , m_queryId(0)
+    , m_pixelsUploaded(0)
 {
     m_queryId = m_context->createQueryEXT();
 }
 
 ThrottledTextureUploader::Query::~Query()
 {
     m_context->deleteQueryEXT(m_queryId);
 }
 
 void ThrottledTextureUploader::Query::begin()
 {
     m_context->beginQueryEXT(Extensions3DChromium::COMMANDS_ISSUED_CHROMIUM, m_queryId);
 }
 
-void ThrottledTextureUploader::Query::end()
+void ThrottledTextureUploader::Query::end(double pixelsUploaded)
 {
     m_context->endQueryEXT(Extensions3DChromium::COMMANDS_ISSUED_CHROMIUM);
+    m_pixelsUploaded = pixelsUploaded;
 }
 
 bool ThrottledTextureUploader::Query::isPending()
 {
     unsigned available = 1;
     m_context->getQueryObjectuivEXT(m_queryId, Extensions3DChromium::QUERY_RESULT_AVAILABLE_EXT, &available);
     return !available;
 }
 
 void ThrottledTextureUploader::Query::wait()
 {
+    value();
+    return;
+}
+
+unsigned ThrottledTextureUploader::Query::value()
+{

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

can you reverse this so that you have m_hasValue, m_value so 
value() {
  if (m_hasValue) return m_value;
   wait;
  return m_value;
}

requires more temporaries but is I think cleaner flowing.

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

Ok. Avoiding the call to getQueryObjectuivEXT multiple times is probably a good
idea.

     unsigned result;
     m_context->getQueryObjectuivEXT(m_queryId, Extensions3DChromium::QUERY_RESULT_EXT, &result);
+    return result;
+}
+
+double ThrottledTextureUploader::Query::pixelsUploaded()
+{
+    return m_pixelsUploaded;
 }
 
 ThrottledTextureUploader::ThrottledTextureUploader(WebKit::WebGraphicsContext3D* context)
     : m_context(context)
     , m_maxPendingQueries(maxPendingQueries)
+    , m_pixelsUploaded(0)
 {
 }
 
 ThrottledTextureUploader::ThrottledTextureUploader(WebKit::WebGraphicsContext3D* context, size_t pendingUploadLimit)
     : m_context(context)
     , m_maxPendingQueries(pendingUploadLimit)
+    , m_pixelsUploaded(0)
 {
     ASSERT(m_context);
 }
 
 ThrottledTextureUploader::~ThrottledTextureUploader()
 {
 }
-
 bool ThrottledTextureUploader::isBusy()
 {
     processQueries();
 
     if (!m_availableQueries.isEmpty())
         return false;
 
     if (m_pendingQueries.size() == m_maxPendingQueries)
         return true;
 
     m_availableQueries.append(Query::create(m_context));
     return false;
 }
 
+double ThrottledTextureUploader::estimatedPixelsPerSecond()
+{
+    processQueries();
+
+    if (m_pixelsPerSecondHistory.empty())

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

Instead of this, seed the queue with max entries worth of the default value.
That gives us a gradual transition to a better guess.

Also, I think we should try putting a global int that is mutable that is our
last guess. And, then, have that be the initial guess as well. So when you
navigate from page to page, we start off with the old guess.

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

Sounds good.

+        return estimatedPixelsPerSecondDefault;
+
+    // Sort the history and use the median as our estimate.
+    std::deque<double> sortedHistory(m_pixelsPerSecondHistory);

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

why deque and not a vector?

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

My thinking was that the deque copy constructor would be faster than the vector
iterator constructor and that it could offset the additional CPU overhead (which
may potentially be hidden anyway) of indexing the deque during sort.

I have not done any measurements to see if that's true but, now that I think
about it, deque indexing will have conditions that can break the pipeline more
than vector indexing.

Probably safer to go with vector.

+    std::sort(sortedHistory.begin(), sortedHistory.end());
+    return sortedHistory[sortedHistory.size() / 2];
+}
+
 void ThrottledTextureUploader::beginUploads()
 {
+    m_pixelsUploaded = 0;
+
     // Wait for query to become available.
     while (isBusy())
         m_pendingQueries.first()->wait();
 
     ASSERT(!m_availableQueries.isEmpty());
     m_availableQueries.first()->begin();
 }
 
 void ThrottledTextureUploader::endUploads()
 {
-    m_availableQueries.first()->end();
+    m_availableQueries.first()->end(m_pixelsUploaded);
     m_pendingQueries.append(m_availableQueries.takeFirst());
 }
 
 void ThrottledTextureUploader::uploadTexture(CCResourceProvider* resourceProvider, Parameters upload)
 {
+    m_pixelsUploaded += upload.sourceRect.width() * upload.sourceRect.width();
     upload.texture->updateRect(resourceProvider, upload.sourceRect, upload.destOffset);
 }
 
 void ThrottledTextureUploader::processQueries()
 {
     while (!m_pendingQueries.isEmpty()) {
         if (m_pendingQueries.first()->isPending())
             break;
 
+        unsigned usElapsed = m_pendingQueries.first()->value();
+        double pixelsPerSecond = m_pendingQueries.first()->pixelsUploaded() / (usElapsed * 1e-6);
+
+        // Remove the oldest values from our history and insert the new one
+        if (m_pixelsPerSecondHistory.size() >= uploadHistorySize)
+            m_pixelsPerSecondHistory.pop_back();
+        m_pixelsPerSecondHistory.push_front(pixelsPerSecond);
+
         m_availableQueries.append(m_pendingQueries.takeFirst());
     }
 }
 
 }