cc: Improve texture per second calculation and overhead

cc/texture_uploader.cc

 // 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 "cc/texture_uploader.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/debug/alias.h"
 #include "base/debug/trace_event.h"
 #include "base/metrics/histogram.h"
 #include "cc/prioritized_texture.h"
 #include "third_party/khronos/GLES2/gl2.h"
 #include "third_party/khronos/GLES2/gl2ext.h"
 #include <public/WebGraphicsContext3D.h>
 
 namespace {
 
 // How many previous uploads to use when predicting future throughput.
-static const size_t uploadHistorySize = 100;
+static const size_t uploadHistorySizeMax = 1000;
+static const size_t uploadHistorySizeInitial = 100;
 
 // Global estimated number of textures per second to maintain estimates across
 // subsequent instances of TextureUploader.
 // More than one thread will not access this variable, so we do not need to synchronize access.
 static double estimatedTexturesPerSecondGlobal = 48.0 * 60.0;

[reveman, 2012/10/23 21:06:58]

Please make this a constant instead. The TextureUploader is only recreated when
we lose the context so I don't think it makes sense to cache this between
instances.

 
 } // anonymous namespace
 
 namespace cc {
 
 TextureUploader::Query::Query(WebKit::WebGraphicsContext3D* context)
     : m_context(context)
     , m_queryId(0)
     , m_value(0)
     , m_hasValue(false)
@@ skipping 41 matching lines @@
 }
 
 bool TextureUploader::Query::isNonBlocking()
 {
     return m_isNonBlocking;
 }
 
 TextureUploader::TextureUploader(
     WebKit::WebGraphicsContext3D* context, bool useMapTexSubImage)
     : m_context(context)
-    , m_texturesPerSecondHistory(uploadHistorySize,
-                                 estimatedTexturesPerSecondGlobal)
     , m_numBlockingTextureUploads(0)
     , m_useMapTexSubImage(useMapTexSubImage)
     , m_subImageSize(0)
 {
+    for (size_t i = uploadHistorySizeInitial; i > 0; i--)
+        m_texturesPerSecondHistory.insert(estimatedTexturesPerSecondGlobal);
 }
 
 TextureUploader::~TextureUploader()
 {
 }
 
 size_t TextureUploader::numBlockingUploads()
 {
     processQueries();
     return m_numBlockingTextureUploads;
@@ skipping 10 matching lines @@
         (*it)->markAsNonBlocking();
     }
 
     DCHECK(!m_numBlockingTextureUploads);
 }
 
 double TextureUploader::estimatedTexturesPerSecond()
 {
     processQueries();
 
-    // The history should never be empty because we initialize all elements with an estimate.
-    DCHECK(m_texturesPerSecondHistory.size() == uploadHistorySize);
-
-    // Sort the history and use the median as our estimate.
-    std::vector<double> sortedHistory(m_texturesPerSecondHistory.begin(),
-                                      m_texturesPerSecondHistory.end());
-    std::sort(sortedHistory.begin(), sortedHistory.end());
-
-    estimatedTexturesPerSecondGlobal = sortedHistory[sortedHistory.size() * 2 / 3];
+    // Use the median as our estimate.
+    std::set<double>::iterator median = m_texturesPerSecondHistory.begin();
+    std::advance(median, m_texturesPerSecondHistory.size() / 2);
+    estimatedTexturesPerSecondGlobal = *median;
     TRACE_COUNTER1("cc", "estimatedTexturesPerSecond", estimatedTexturesPerSecondGlobal);
     return estimatedTexturesPerSecondGlobal;
 }
 
 void TextureUploader::beginQuery()
 {
     if (m_availableQueries.isEmpty())
       m_availableQueries.append(Query::create(m_context));
 
     m_availableQueries.first()->begin();
@@ skipping 187 matching lines @@
     while (!m_pendingQueries.isEmpty()) {
         if (m_pendingQueries.first()->isPending())
             break;
 
         unsigned usElapsed = m_pendingQueries.first()->value();
         HISTOGRAM_CUSTOM_COUNTS("Renderer4.TextureGpuUploadTimeUS", usElapsed, 0, 100000, 50);
 
         if (!m_pendingQueries.first()->isNonBlocking())
             m_numBlockingTextureUploads--;
 
-        // Remove the oldest values from our history and insert the new one
+        // Remove the min and max value from our history and insert the new one.
         double texturesPerSecond = 1.0 / (usElapsed * 1e-6);
-        m_texturesPerSecondHistory.pop_back();
-        m_texturesPerSecondHistory.push_front(texturesPerSecond);
+        if (m_texturesPerSecondHistory.size() >= uploadHistorySizeMax) {
+            m_texturesPerSecondHistory.erase(m_texturesPerSecondHistory.begin());
+            m_texturesPerSecondHistory.erase(--m_texturesPerSecondHistory.end());
+        }
+        m_texturesPerSecondHistory.insert(texturesPerSecond);
 
         m_availableQueries.append(m_pendingQueries.takeFirst());
     }
 }
 
 }