Adaptively throttle texture uploads

cc/CCLayerTreeHost.cpp

 // Copyright 2011 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 "CCLayerTreeHost.h"
 
 #include "CCFontAtlas.h"
 #include "CCGraphicsContext.h"
@@ skipping 50 matching lines @@
     , m_numFailedRecreateAttempts(0)
     , m_settings(settings)
     , m_deviceScaleFactor(1)
     , m_visible(true)
     , m_pageScaleFactor(1)
     , m_minPageScaleFactor(1)
     , m_maxPageScaleFactor(1)
     , m_triggerIdleUpdates(true)
     , m_backgroundColor(SK_ColorWHITE)
     , m_hasTransparentBackground(false)
+    , m_maxPartialTextureUpdates(0)
     , m_partialTextureUpdateRequests(0)
 {
     ASSERT(CCProxy::isMainThread());
     numLayerTreeInstances++;
 }
 
 bool CCLayerTreeHost::initialize()
 {
     TRACE_EVENT0("cc", "CCLayerTreeHost::initialize");
 
@@ skipping 31 matching lines @@
     TRACE_EVENT0("cc", "CCLayerTreeHost::initializeRenderer");
     if (!m_proxy->initializeRenderer()) {
         // Uh oh, better tell the client that we can't do anything with this context.
         m_client->didRecreateOutputSurface(false);
         return;
     }
 
     // Update m_settings based on capabilities that we got back from the renderer.
     m_settings.acceleratePainting = m_proxy->rendererCapabilities().usingAcceleratedPainting;
 
-    // Update m_settings based on partial update capability.
-    m_settings.maxPartialTextureUpdates = min(m_settings.maxPartialTextureUpdates, m_proxy->maxPartialTextureUpdates());
-
     m_contentsTextureManager = CCPrioritizedTextureManager::create(0, m_proxy->rendererCapabilities().maxTextureSize, CCRenderer::ContentPool);
     m_surfaceMemoryPlaceholder = m_contentsTextureManager->createTexture(IntSize(), GraphicsContext3D::RGBA);
 
     m_rendererInitialized = true;
 
     m_settings.defaultTileSize = IntSize(min(m_settings.defaultTileSize.width(), m_proxy->rendererCapabilities().maxTextureSize),
                                          min(m_settings.defaultTileSize.height(), m_proxy->rendererCapabilities().maxTextureSize));
     m_settings.maxUntiledLayerSize = IntSize(min(m_settings.maxUntiledLayerSize.width(), m_proxy->rendererCapabilities().maxTextureSize),
                                              min(m_settings.maxUntiledLayerSize.height(), m_proxy->rendererCapabilities().maxTextureSize));
 }
@@ skipping 309 matching lines @@
         if (!m_rendererInitialized)
             return false;
     }
     if (m_contextLost) {
         if (recreateContext() != RecreateSucceeded)
             return false;
     }
     return true;
 }
 
-void CCLayerTreeHost::updateLayers(CCTextureUpdateQueue& queue, size_t memoryAllocationLimitBytes)
+void CCLayerTreeHost::updateLayers(CCTextureUpdateQueue& queue, size_t memoryAllocationLimitBytes, size_t *maxTextureUpdates)
 {
     ASSERT(m_rendererInitialized);
     ASSERT(memoryAllocationLimitBytes);
 
     if (!rootLayer())
         return;
 
     if (layoutViewportSize().isEmpty())
         return;
 
     m_contentsTextureManager->setMaxMemoryLimitBytes(memoryAllocationLimitBytes);
 
-    updateLayers(rootLayer(), queue);
+    updateLayers(rootLayer(), queue, maxTextureUpdates);
 }
 
 static void setScale(LayerChromium* layer, float deviceScaleFactor, float pageScaleFactor)
 {
     if (layer->boundsContainPageScale())
         layer->setContentsScale(deviceScaleFactor);
     else
         layer->setContentsScale(deviceScaleFactor * pageScaleFactor);
 }
 
 static void updateLayerScale(LayerChromium* layer, float deviceScaleFactor, float pageScaleFactor)
 {
     setScale(layer, deviceScaleFactor, pageScaleFactor);
 
     LayerChromium* maskLayer = layer->maskLayer();
     if (maskLayer)
         setScale(maskLayer, deviceScaleFactor, pageScaleFactor);
 
     LayerChromium* replicaMaskLayer = layer->replicaLayer() ? layer->replicaLayer()->maskLayer() : 0;
     if (replicaMaskLayer)
         setScale(replicaMaskLayer, deviceScaleFactor, pageScaleFactor);
 
     const Vector<RefPtr<LayerChromium> >& children = layer->children();
     for (unsigned int i = 0; i < children.size(); ++i)
         updateLayerScale(children[i].get(), deviceScaleFactor, pageScaleFactor);
 }
 
-void CCLayerTreeHost::updateLayers(LayerChromium* rootLayer, CCTextureUpdateQueue& queue)
+void CCLayerTreeHost::updateLayers(LayerChromium* rootLayer, CCTextureUpdateQueue& queue, size_t *maxTextureUpdates)
 {
     TRACE_EVENT0("cc", "CCLayerTreeHost::updateLayers");
 
     updateLayerScale(rootLayer, m_deviceScaleFactor, m_pageScaleFactor);
 
     LayerList updateList;
 
     {
         TRACE_EVENT0("cc", "CCLayerTreeHost::updateLayers::calcDrawEtc");
         CCLayerTreeHostCommon::calculateDrawTransforms(rootLayer, deviceViewportSize(), m_deviceScaleFactor, rendererCapabilities().maxTextureSize, updateList);
         CCLayerTreeHostCommon::calculateVisibleRects(updateList);
     }
 
     // Reset partial texture update requests.
     m_partialTextureUpdateRequests = 0;
+    m_maxPartialTextureUpdates = std::min(m_settings.maxPartialTextureUpdates, *maxTextureUpdates);
+    *maxTextureUpdates = m_maxPartialTextureUpdates; // We need to communicate that we've clamped.

[brianderson, 2012/09/13 20:09:26]

Actually, I shouldn't communicate that we've clamped here.  Otherwise partial
texture upload limits on the main thread will affect the full texture upload
limit on the impl thread.

 
     bool needMoreUpdates = paintLayerContents(updateList, queue);
     if (m_triggerIdleUpdates && needMoreUpdates)
         setNeedsCommit();
 
     for (size_t i = 0; i < updateList.size(); ++i)
         updateList[i]->clearRenderSurface();
 }
 
 void CCLayerTreeHost::setPrioritiesForSurfaces(size_t surfaceMemoryBytes)
@@ skipping 188 matching lines @@
     m_proxy->forceSerializeOnSwapBuffers();
 }
 
 bool CCLayerTreeHost::bufferedUpdates()
 {
     return m_settings.maxPartialTextureUpdates != numeric_limits<size_t>::max();
 }
 
 bool CCLayerTreeHost::requestPartialTextureUpdate()
 {
-    if (m_partialTextureUpdateRequests >= m_settings.maxPartialTextureUpdates)
+    if (m_partialTextureUpdateRequests >= m_maxPartialTextureUpdates)
         return false;
 
     m_partialTextureUpdateRequests++;
     return true;
 }
 
 void CCLayerTreeHost::deleteTextureAfterCommit(PassOwnPtr<CCPrioritizedTexture> texture)
 {
     m_deleteTextureAfterCommitList.append(texture);
 }
@@ skipping 49 matching lines @@
             else
                 layer->notifyAnimationFinished(wallClockTime);
         }
     }
 
     for (size_t childIndex = 0; childIndex < layer->children().size(); ++childIndex)
         setAnimationEventsRecursive(events, layer->children()[childIndex].get(), wallClockTime);
 }
 
 } // namespace WebCore