cc: Decrease transfer buffer memory limit to a single frame of uploads.

cc/trees/layer_tree_host_impl.cc

 // 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 "cc/trees/layer_tree_host_impl.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/basictypes.h"
@@ skipping 71 matching lines @@
                              "LayerTreeHostImpl::SetVisible",
                              id,
                              "LayerTreeHostImpl",
                              id);
     return;
   }
 
   TRACE_EVENT_ASYNC_END0("webkit", "LayerTreeHostImpl::SetVisible", id);
 }
 
-size_t GetMaxTransferBufferUsageBytes(cc::ContextProvider* context_provider) {
+size_t GetMaxTransferBufferUsageBytes(cc::ContextProvider* context_provider,
+                                      double refresh_rate) {
   // Software compositing should not use this value in production. Just use a
   // default value when testing uploads with the software compositor.
   if (!context_provider)
     return std::numeric_limits<size_t>::max();
 
   // We want to make sure the default transfer buffer size is equal to the
   // amount of data that can be uploaded by the compositor to avoid stalling
   // the pipeline.
   // For reference Chromebook Pixel can upload 1MB in about 0.5ms.
   const size_t kMaxBytesUploadedPerMs = 1024 * 1024 * 2;
-  // Assuming a two frame deep pipeline between CPU and GPU and we are
-  // drawing 60 frames per second which would require us to draw one
-  // frame in 16 milliseconds.
-  const size_t kMaxTransferBufferUsageBytes = 16 * 2 * kMaxBytesUploadedPerMs;
+
+  // This is the number of bytes the compositor would be able to upload before
+  // the next frame deadline.

[reveman, 2014/08/30 00:38:39]

maybe worth mentioning that this assumes no more than a one frame deep pipeline
between CPU and GPU. and if we have more than that it might cause us to issue
less uploads than we can perform.  

[danakj, 2014/08/30 00:51:38]

I added something, let me know if you think it's a lie :)

+  const size_t ms_per_frame = std::floor(1000.0 / refresh_rate);
+  const size_t max_transfer_buffer_usage_bytes =
+      ms_per_frame * kMaxBytesUploadedPerMs;

[reveman, 2014/08/30 00:38:39]

nit: up to you but I'd get rid of the 'const' modifier here

[danakj, 2014/08/30 00:42:32]

Done.

+
+  // The context may request a higher limit based on the device capabilities.

[reveman, 2014/08/30 00:38:39]

nit: lower limit based on the device capabilities.

[danakj, 2014/08/30 00:42:32]

I would have to change std::min to std::max then. Right now it can only increase
the number. Maybe this points to a bug, I will file one.

[danakj, 2014/08/30 00:44:28]

Oh, no I agree with you. Fridays~

   return std::min(
       context_provider->ContextCapabilities().max_transfer_buffer_usage_bytes,
-      kMaxTransferBufferUsageBytes);
+      max_transfer_buffer_usage_bytes);
 }
 
 unsigned GetMapImageTextureTarget(cc::ContextProvider* context_provider) {
   if (!context_provider)
     return GL_TEXTURE_2D;
 
   if (context_provider->ContextCapabilities().gpu.egl_image_external)
     return GL_TEXTURE_EXTERNAL_OES;
   if (context_provider->ContextCapabilities().gpu.texture_rectangle)
     return GL_TEXTURE_RECTANGLE_ARB;
@@ skipping 1812 matching lines @@
 
 void LayerTreeHostImpl::CreateAndSetTileManager() {
   DCHECK(!tile_manager_);
   DCHECK(settings_.impl_side_painting);
   DCHECK(output_surface_);
   DCHECK(resource_provider_);
   DCHECK(proxy_->ImplThreadTaskRunner());
 
   ContextProvider* context_provider = output_surface_->context_provider();
   transfer_buffer_memory_limit_ =
-      GetMaxTransferBufferUsageBytes(context_provider);
+      GetMaxTransferBufferUsageBytes(context_provider, settings_.refresh_rate);
 
   if (use_gpu_rasterization_ && context_provider) {
     resource_pool_ =
         ResourcePool::Create(resource_provider_.get(),
                              GL_TEXTURE_2D,
                              resource_provider_->best_texture_format());
 
     raster_worker_pool_ =
         GpuRasterWorkerPool::Create(proxy_->ImplThreadTaskRunner(),
                                     context_provider,
@@ skipping 106 matching lines @@
                                settings_.highp_threshold_min,
                                settings_.use_rgba_4444_textures,
                                settings_.texture_id_allocation_chunk_size,
                                settings_.use_distance_field_text);
 
   if (output_surface_->capabilities().deferred_gl_initialization)
     EnforceZeroBudget(true);
 
   CreateAndSetRenderer();
 
-  transfer_buffer_memory_limit_ =

[danakj, 2014/08/30 00:29:00]

this is also set in CreateAndSetTileManager() which is called next.

-      GetMaxTransferBufferUsageBytes(output_surface_->context_provider());
-
   if (settings_.impl_side_painting)
     CreateAndSetTileManager();
 
   // Initialize vsync parameters to sane values.
   const base::TimeDelta display_refresh_interval =
       base::TimeDelta::FromMicroseconds(base::Time::kMicrosecondsPerSecond /
                                         settings_.refresh_rate);
   CommitVSyncParameters(base::TimeTicks(), display_refresh_interval);
 
   // TODO(brianderson): Don't use a hard-coded parent draw time.
@@ skipping 1270 matching lines @@
 }
 
 void LayerTreeHostImpl::UnregisterPictureLayerImpl(PictureLayerImpl* layer) {
   std::vector<PictureLayerImpl*>::iterator it =
       std::find(picture_layers_.begin(), picture_layers_.end(), layer);
   DCHECK(it != picture_layers_.end());
   picture_layers_.erase(it);
 }
 
 }  // namespace cc