Global GPU memory manager for android webview

android_webview/browser/browser_view_renderer.cc

 // Copyright 2014 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 "android_webview/browser/browser_view_renderer.h"
 
 #include "android_webview/browser/browser_view_renderer_client.h"
 #include "android_webview/browser/shared_renderer_state.h"
 #include "android_webview/public/browser/draw_gl.h"
 #include "base/android/jni_android.h"
 #include "base/auto_reset.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
 #include "content/public/browser/android/synchronous_compositor.h"
+#include "content/public/browser/browser_thread.h"
 #include "content/public/browser/web_contents.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkPicture.h"
 #include "ui/gfx/vector2d_conversions.h"
 
 using base::android::AttachCurrentThread;
 using base::android::JavaRef;
 using base::android::ScopedJavaLocalRef;
+using content::BrowserThread;
+using content::SynchronousCompositorMemoryPolicy;
 
 namespace android_webview {
 
 namespace {
 
 const int64 kFallbackTickTimeoutInMilliseconds = 20;
 
+// Used to calculate memory and resource allocation. Determined experimentally.
+const size_t kMemoryMultiplier = 10;
+// The number of tiles needed if the view takes up the whole viewport.
+const size_t kNumGrallocLimit = 150;
+const size_t kBytesPerPixel = 4;
+const size_t kMemoryAllocationStep = 5 * 1024 * 1024;
+const size_t kTileAllocationStep = 20;
+// Becomes starved if the resource request cannot be granted kStarvedTimes in a
+// row. Let it be 1 for now to make it super aggresssive to evict other views.
+const size_t kStarvedTimes = 1;
+
 class AutoResetWithLock {
  public:
   AutoResetWithLock(gfx::Vector2dF* scoped_variable,
                     gfx::Vector2dF new_value,
                     base::Lock& lock)
       : scoped_variable_(scoped_variable),
         original_value_(*scoped_variable),
         lock_(lock) {
     base::AutoLock auto_lock(lock_);
     *scoped_variable_ = new_value;
@@ skipping 30 matching lines @@
       view_visible_(false),
       window_visible_(false),
       attached_to_window_(false),
       dip_scale_(0.0),
       page_scale_factor_(1.0),
       on_new_picture_enable_(false),
       clear_view_(false),
       compositor_needs_continuous_invalidate_(false),
       block_invalidates_(false),
       width_(0),
-      height_(0) {
+      height_(0),
+      num_consecutive_hungry_frames_(0) {
   CHECK(web_contents_);
   content::SynchronousCompositor::SetClientForWebContents(web_contents_, this);
-
   // Currently the logic in this class relies on |has_compositor_| remaining
   // false until the DidInitializeCompositor() call, hence it is not set here.
 }
 
 BrowserViewRenderer::~BrowserViewRenderer() {
   content::SynchronousCompositor::SetClientForWebContents(web_contents_, NULL);
+  // OnDetachedFromWindow should be called before the destructor, so the memory
+  // policy should have already been updated.
+}
+
+// This function updates the cached memory policy in shared renderer state, as
+// well as the tile resource allocation in GlobalTileManager.
+void BrowserViewRenderer::TrimMemory(const int level, const bool visible) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  // Constants from Android ComponentCallbacks2.
+  enum {
+    TRIM_MEMORY_RUNNING_LOW = 10,
+    TRIM_MEMORY_UI_HIDDEN = 20,
+    TRIM_MEMORY_BACKGROUND = 40,
+  };
+
+  // Not urgent enough. TRIM_MEMORY_UI_HIDDEN is treated specially because
+  // it does not indicate memory pressure, but merely that the app is
+  // backgrounded.
+  if (level < TRIM_MEMORY_RUNNING_LOW || level == TRIM_MEMORY_UI_HIDDEN)
+    return;
+
+  // Do not release resources on view we expect to get DrawGL soon.
+  if (level < TRIM_MEMORY_BACKGROUND && visible)
+    return;
+
+  // Just set the memory limit to 0 and drop all tiles. This will be reset to
+  // normal levels in the next DrawGL call.
+  SynchronousCompositorMemoryPolicy zero_policy;
+  if (shared_renderer_state_->GetMemoryPolicy() == zero_policy)
+    return;
+
+  TRACE_EVENT0("android_webview", "BrowserViewRenderer::TrimMemory");
+
+  RequestMemoryPolicy(zero_policy);
+  ForceDropTiles();
+}
+
+SynchronousCompositorMemoryPolicy
+BrowserViewRenderer::CalculateDesiredMemoryPolicy() {
+  SynchronousCompositorMemoryPolicy policy;
+  policy.bytes_limit = kMemoryMultiplier * kBytesPerPixel *
+                       draw_gl_input_.global_visible_rect.width() *
+                       draw_gl_input_.global_visible_rect.height();
+  // Round up to a multiple of kMemoryAllocationStep.
+  policy.bytes_limit =
+      (policy.bytes_limit / kMemoryAllocationStep + 1) * kMemoryAllocationStep;
+  policy.num_resources_limit = CalculateTileRequest();
+  return policy;
+}
+
+// This function updates the cached memory policy in shared renderer state, as
+// well as the tile resource allocation in GlobalTileManager.
+void BrowserViewRenderer::RequestMemoryPolicy(
+    SynchronousCompositorMemoryPolicy& new_policy) {
+  SynchronousCompositorMemoryPolicy current_policy =
+      shared_renderer_state_->GetMemoryPolicy();
+  GlobalTileManager* manager = GlobalTileManager::GetInstance();
+
+  size_t num_tiles = manager->RequestTiles(current_policy.num_resources_limit,
+                                           new_policy.num_resources_limit,
+                                           NeedsEviction(),
+                                           tile_manager_key_);
+  if (num_tiles < new_policy.num_resources_limit)
+    num_consecutive_hungry_frames_++;
+  else
+    num_consecutive_hungry_frames_ = 0;
+
+  new_policy.num_resources_limit = num_tiles;
+  shared_renderer_state_->SetMemoryPolicy(new_policy);
+}
+
+size_t BrowserViewRenderer::CalculateTileRequest() const {
+  double area = (double)draw_gl_input_.global_visible_rect.width() *

[boliu, 2014/05/01 00:37:40]

against style guide to use c-style casts, always use things like static_cast<>

Don't read out of draw_gl_input, pass them in as parameters

Viewport is not the right number here, what you want is the screen size. View
size can be way bigger than screen (think gmail).

Considering the current screen sizes of devices, and the fact that (max) tile
size is 372x372, can we use a heuristic that does not rely on screen size? So
like how we calculate memory as visible size * constant, can we do the same
here? Of course experiment first.

[hush (inactive), 2014/05/01 19:03:04]

CalculateTileRequest() is an inherited method. I will overload
CalculateTileRequest so that it takes width and height.

For now, I will just use a multiplier of 12. On a Nexus 5, a full screen view
will use around 150. On a Nexus 7, a full screen will use around 80 tiles.
Plumbing down the screen sizes from Java to native bvr takes additional work and
may be done later.

On 2014/05/01 00:37:40, boliu wrote:

+                draw_gl_input_.global_visible_rect.height();
+  double viewport = (double)draw_gl_input_.width * draw_gl_input_.height;
+  // Round up to a multiple of kTileAllocationStep. The minimum number of tiles
+  // is also kTileAllocationStep.
+  size_t tiles = std::max(kNumGrallocLimit * (area / viewport), 1.0);
+  tiles = (tiles + kTileAllocationStep - 1) / kTileAllocationStep *
+          kTileAllocationStep;
+  return tiles;
+}
+
+bool BrowserViewRenderer::NeedsEviction() const {
+  // If the hardware renderer is hungry for kStarvedTimes in a row, this
+  // browser view renderer is considered starved.
+  return num_consecutive_hungry_frames_ >= kStarvedTimes;
+}
+
+size_t BrowserViewRenderer::ForceDropTiles() {
+  size_t dropped_tiles = GetTilesNum();
+  SynchronousCompositorMemoryPolicy zero_policy;
+
+  shared_renderer_state_->SetMemoryPolicy(zero_policy);
+  shared_renderer_state_->GetCompositor()->SetMemoryPolicy(zero_policy);
+
+  // Now force a fake SW draw to make sure the tiles are dropped because the
+  // tile manager only manages tiles after a Draw.
+  // Making a fake SW draw is a hacky way to forcibly drop tiles. Maybe we can
+  // find better implementations.
+  ForceFakeCompositeSW();
+  return dropped_tiles;
+}
+
+size_t BrowserViewRenderer::GetTilesNum() const {
+  return shared_renderer_state_->GetMemoryPolicy().num_resources_limit;
 }
 
 bool BrowserViewRenderer::OnDraw(jobject java_canvas,
                                  bool is_hardware_canvas,
                                  const gfx::Vector2d& scroll,
                                  const gfx::Rect& global_visible_rect,
                                  const gfx::Rect& clip) {
   draw_gl_input_.frame_id++;
   draw_gl_input_.scroll_offset = scroll;
   draw_gl_input_.global_visible_rect = global_visible_rect;
   draw_gl_input_.width = width_;
   draw_gl_input_.height = height_;
   if (clear_view_)
     return false;
   if (is_hardware_canvas && attached_to_window_) {
     shared_renderer_state_->SetDrawGLInput(draw_gl_input_);
+
+    SynchronousCompositorMemoryPolicy old_policy =
+        shared_renderer_state_->GetMemoryPolicy();
+    SynchronousCompositorMemoryPolicy new_policy =
+        CalculateDesiredMemoryPolicy();
+    RequestMemoryPolicy(new_policy);
     // We should be performing a hardware draw here. If we don't have the
     // compositor yet or if RequestDrawGL fails, it means we failed this draw
     // and thus return false here to clear to background color for this draw.
-    return has_compositor_ && client_->RequestDrawGL(java_canvas);
+    bool did_draw_gl = has_compositor_ && client_->RequestDrawGL(java_canvas);
+    if (did_draw_gl)
+      GlobalTileManager::GetInstance()->DidUse(tile_manager_key_);
+    else
+      RequestMemoryPolicy(old_policy);
+
+    return did_draw_gl;
   }
   // Perform a software draw
   return DrawSWInternal(java_canvas, clip);
 }
 
 void BrowserViewRenderer::DidDrawGL(const DrawGLResult& result) {
   DidComposite(!result.clip_contains_visible_rect);
 }
 
 bool BrowserViewRenderer::DrawSWInternal(jobject java_canvas,
@@ skipping 101 matching lines @@
 void BrowserViewRenderer::OnAttachedToWindow(int width, int height) {
   TRACE_EVENT2("android_webview",
                "BrowserViewRenderer::OnAttachedToWindow",
                "width",
                width,
                "height",
                height);
   attached_to_window_ = true;
   width_ = width;
   height_ = height;
+  tile_manager_key_ = GlobalTileManager::GetInstance()->PushBack(this);
+  num_consecutive_hungry_frames_ = 0;
 }
 
 void BrowserViewRenderer::OnDetachedFromWindow() {
   TRACE_EVENT0("android_webview", "BrowserViewRenderer::OnDetachedFromWindow");
   attached_to_window_ = false;
+  SynchronousCompositorMemoryPolicy zero_policy;
+  RequestMemoryPolicy(zero_policy);
+  GlobalTileManager::GetInstance()->Remove(tile_manager_key_);
+  num_consecutive_hungry_frames_ = 0;
+  // The hardware resources are released in the destructor of hardware renderer,
+  // so we don't need to do it here.
+  // See AwContents::ReleaseHardwareDrawOnRenderThread(JNIEnv*, jobject).
 }
 
 bool BrowserViewRenderer::IsAttachedToWindow() const {
   return attached_to_window_;
 }
 
 bool BrowserViewRenderer::IsVisible() const {
   // Ignore |window_visible_| if |attached_to_window_| is false.
   return view_visible_ && (!attached_to_window_ || window_visible_);
 }
@@ skipping 13 matching lines @@
   shared_renderer_state_->SetCompositorOnUiThread(compositor);
 }
 
 void BrowserViewRenderer::DidDestroyCompositor(
     content::SynchronousCompositor* compositor) {
   TRACE_EVENT0("android_webview", "BrowserViewRenderer::DidDestroyCompositor");
   DCHECK(has_compositor_);
   DCHECK(ui_task_runner_->BelongsToCurrentThread());
   has_compositor_ = false;
   shared_renderer_state_->SetCompositorOnUiThread(NULL);
+  SynchronousCompositorMemoryPolicy zero_policy;
+  DCHECK(shared_renderer_state_->GetMemoryPolicy() == zero_policy);
 }
 
 void BrowserViewRenderer::SetContinuousInvalidate(bool invalidate) {
   if (!ui_task_runner_->BelongsToCurrentThread()) {
     ui_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&BrowserViewRenderer::SetContinuousInvalidate,
                    ui_thread_weak_ptr_,
                    invalidate));
     return;
@@ skipping 317 matching lines @@
     base::StringAppendF(&str,
                         "surface width height: [%d %d] ",
                         draw_info->width,
                         draw_info->height);
     base::StringAppendF(&str, "is_layer: %d ", draw_info->is_layer);
   }
   return str;
 }
 
 }  // namespace android_webview