cc: Set the mapped memory reclaim limit for the renderer compositor on Android

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"
 #include "base/containers/hash_tables.h"
 #include "base/json/json_writer.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "cc/animation/scrollbar_animation_controller.h"
 #include "cc/animation/timing_function.h"
 #include "cc/base/math_util.h"
@@ skipping 44 matching lines @@
                              "LayerTreeHostImpl::SetVisible",
                              id,
                              "LayerTreeHostImpl",
                              id);
     return;
   }
 
   TRACE_EVENT_ASYNC_END0("webkit", "LayerTreeHostImpl::SetVisible", id);
 }
 
+size_t GetMaxBytesPendingUpload(cc::ContextProvider* context_provider) {

[reveman, 2013/09/05 17:52:10]

GetMaxTransferBufferUsageBytes instead please and update constants and comments
below

+  if (context_provider != NULL) {

[reveman, 2013/09/03 22:01:50]

is this really the correct way to determine the limit? What if
output_surface->ForcedDrawToSoftwareDevice() is true? Should it be based on the
return value of GetDrawMode instead?

[danakj, 2013/09/03 22:19:25]

AIUI This limit is how much the compositor should upload at a time, uploading
only happens if you have a context3d. The value is ignored if you are doing
software compositing, cuz you're not uploading. Are you proposing that this
function is returning something different?

[reveman, 2013/09/04 23:22:15]

we should always be using std::numeric_limits<size_t>::max() with sw
compositing. that doesn't seem to be the case at the moment unless I'm missing
something?

[danakj, 2013/09/05 14:36:17]

We don't recreate the TileManager when we draw a software resourceless frame in
the middle of a bunch of GL frames. Maybe that's the confusion. Output Surface
can change its ForceDrawToSoftwareDevice on/off at the time of each draw in cc.
So that is independent from and can't be used to determine how to set up the
TileManager.

It's kinda odd, but on webview I believe we start we start in SOFTWARE mode,
with a zero budget. Then move to HARDWARE mode, with intermixed
RESOURCELESS_SOFTWARE frames intermixed where we create a SoftwareRenderer on
the fly for each frame.

So I think this does exactly what you're looking for?

[reveman, 2013/09/05 15:32:14]

Hm, we're still using the tile manager to initialize tiles in software mode,
right? In that case, using a limit less than numeric_limits<size_t>::max() will
effect the behavior of PBRWP.

I generally find it confusing that the code and comments here seem to assume
that "context_provider != NULL" means not using software while that is not the
case. I think some renaming is required at a minimum.

[danakj, 2013/09/05 15:35:07]

No, resourceless software mode means there are no resources, it just draws from
the SkPictures. There's no interaction with tile manager at all AFAIK.
The whole situation is complicated and hard to understand. I want to improve it.
https://docs.google.com/a/chromium.org/document/d/1YcEU09zkVvg86C05MbLjeKFLIG...

context_provider != NULL means using GL resources. context_provider == NULL
means using software resources. This is currently so for the life of the
TileManager/Renderer/ResourceProvider.

[reveman, 2013/09/05 17:52:10]

Ok, got it.

nit: "if (context_provider)" instead

[kaanb, 2013/09/05 19:26:57]

Done.

+    // For reference Chromebook Pixel can upload 1MB in about 0.5ms.
+    const size_t kMaxBytesUploadedPerMs = 1024 * 1024 * 2;

[reveman, 2013/09/03 22:01:50]

nit: kMaxTransferBufferUsageBytes here and below

[kaanb, 2013/09/03 23:09:29]

Done.

+    // 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 kMaxBytesPendingUpload = 16 * 2 * kMaxBytesUploadedPerMs;
+    return std::min(
+        context_provider->ContextCapabilities().max_transfer_buffer_usage_bytes,
+        kMaxBytesPendingUpload);
+  } else {
+    // Software compositing should not use this path in production. Just use a

[danakj, 2013/09/03 21:48:29]

s/path/value/

[kaanb, 2013/09/03 23:09:29]

Done.

+    // default value when testing this path with software compositor.

[danakj, 2013/09/03 21:48:29]

...when testing uploads with the software compositor.

[kaanb, 2013/09/03 23:09:29]

Done.

+    return std::numeric_limits<size_t>::max();
+  }
+}
+
 }  // namespace
 
 namespace cc {
 
 class LayerTreeHostImplTimeSourceAdapter : public TimeSourceClient {
  public:
   static scoped_ptr<LayerTreeHostImplTimeSourceAdapter> Create(
       LayerTreeHostImpl* layer_tree_host_impl,
       scoped_refptr<DelayBasedTimeSource> time_source) {
     return make_scoped_ptr(
@@ skipping 1505 matching lines @@
   }
 
   if (renderer_) {
     renderer_->SetVisible(visible_);
     SetFullRootLayerDamage();
   }
 }
 
 void LayerTreeHostImpl::CreateAndSetTileManager(
     ResourceProvider* resource_provider,
-    bool using_map_image) {
+    bool using_map_image,
+    ContextProvider* context_provider) {
   DCHECK(settings_.impl_side_painting);
   DCHECK(resource_provider);
-  tile_manager_ = TileManager::Create(this,
-                                      resource_provider,
-                                      settings_.num_raster_threads,
-                                      rendering_stats_instrumentation_,
-                                      using_map_image);
+  tile_manager_ =
+      TileManager::Create(this,
+                          resource_provider,
+                          settings_.num_raster_threads,
+                          rendering_stats_instrumentation_,
+                          using_map_image,
+                          GetMaxBytesPendingUpload(context_provider));
+
   UpdateTileManagerMemoryPolicy(ActualManagedMemoryPolicy());
   need_to_update_visible_tiles_before_draw_ = false;
 }
 
 void LayerTreeHostImpl::EnforceZeroBudget(bool zero_budget) {
   SetManagedMemoryPolicy(cached_managed_memory_policy_, zero_budget);
 }
 
 bool LayerTreeHostImpl::InitializeRenderer(
     scoped_ptr<OutputSurface> output_surface) {
@@ skipping 23 matching lines @@
 
   bool skip_gl_renderer = false;
   CreateAndSetRenderer(
       output_surface.get(), resource_provider.get(), skip_gl_renderer);
 
   if (!renderer_)
     return false;
 
   if (settings_.impl_side_painting) {
     CreateAndSetTileManager(resource_provider.get(),
-                            GetRendererCapabilities().using_map_image);
+                            GetRendererCapabilities().using_map_image,
+                            output_surface->context_provider().get());
   }
 
   // Setup BeginFrameEmulation if it's not supported natively
   if (!settings_.begin_frame_scheduling_enabled) {
     const base::TimeDelta display_refresh_interval =
       base::TimeDelta::FromMicroseconds(
           base::Time::kMicrosecondsPerSecond /
           settings_.refresh_rate);
 
     output_surface->InitializeBeginFrameEmulation(
@@ skipping 91 matching lines @@
   tile_manager_.reset();
   resource_provider_->InitializeSoftware();
 
   bool skip_gl_renderer = true;
   CreateAndSetRenderer(
       output_surface_.get(), resource_provider_.get(), skip_gl_renderer);
   DCHECK(renderer_);
 
   EnforceZeroBudget(true);
   CreateAndSetTileManager(resource_provider_.get(),
-                          GetRendererCapabilities().using_map_image);
+                          GetRendererCapabilities().using_map_image,
+                          NULL);
+
   DCHECK(tile_manager_);
 
   SetOffscreenContextProvider(NULL);
 
   client_->SetNeedsCommitOnImplThread();
 }
 
 void LayerTreeHostImpl::SetViewportSize(gfx::Size device_viewport_size) {
   if (device_viewport_size == device_viewport_size_)
     return;
@@ skipping 806 matching lines @@
 
 ResourceProvider::ResourceId LayerTreeHostImpl::ResourceIdForUIResource(
     UIResourceId uid) const {
   UIResourceMap::const_iterator iter = ui_resource_map_.find(uid);
   if (iter != ui_resource_map_.end())
     return iter->second;
   return 0;
 }
 
 }  // namespace cc