1// Copyright 2014 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "android_webview/browser/global_tile_manager.h"
6#include "android_webview/browser/global_tile_manager_client.h"
7#include "base/lazy_instance.h"
8
9using content::SynchronousCompositorMemoryPolicy;
10
11namespace android_webview {
12
13namespace {
14
15base::LazyInstance<GlobalTileManager>::Leaky g_tile_manager =
16    LAZY_INSTANCE_INITIALIZER;
17
18// The soft limit of the number of file descriptors per process is 1024 on
19// Android and gralloc buffers may not be the only thing that uses file
20// descriptors. For each tile, there is a gralloc buffer backing it, which
21// uses 2 FDs.
22const size_t kNumTilesLimit = 450;
23
24}  // namespace
25
26// static
27GlobalTileManager* GlobalTileManager::GetInstance() {
28  return g_tile_manager.Pointer();
29}
30
31void GlobalTileManager::Remove(Key key) {
32  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
33  DCHECK(mru_list_.end() != key);
34
35  total_allocated_tiles_ -= (*key)->GetMemoryPolicy().num_resources_limit;
36  mru_list_.erase(key);
37  DCHECK(IsConsistent());
38}
39
40size_t GlobalTileManager::Evict(size_t desired_num_tiles, Key key) {
41  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
42  size_t total_evicted_tiles = 0;
43
44  // Evicts from the least recent drawn view, until the disired number of tiles
45  // can be reclaimed, or until we've evicted all inactive views.
46  ListType::reverse_iterator it;
47  for (it = mru_list_.rbegin(); it != mru_list_.rend(); it++) {
48    // key represents the view that requested the eviction, so we don't need to
49    // evict the requester itself. And we only evict the inactive views,
50    // which are all the views after the requester.
51    if (*it == *key)
52      break;
53
54    size_t evicted_tiles = (*it)->GetMemoryPolicy().num_resources_limit;
55    SynchronousCompositorMemoryPolicy zero_policy;
56    (*it)->SetMemoryPolicy(zero_policy, true);
57
58    total_evicted_tiles += evicted_tiles;
59    if (total_evicted_tiles >= desired_num_tiles)
60      break;
61  }
62
63  return total_evicted_tiles;
64}
65
66void GlobalTileManager::SetTileLimit(size_t num_tiles_limit) {
67  num_tiles_limit_ = num_tiles_limit;
68}
69
70void GlobalTileManager::RequestTiles(
71    SynchronousCompositorMemoryPolicy new_policy,
72    Key key) {
73  DCHECK(IsConsistent());
74  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
75  size_t new_num_of_tiles = new_policy.num_resources_limit;
76  size_t old_num_of_tiles = (*key)->GetMemoryPolicy().num_resources_limit;
77  size_t num_of_active_views = std::distance(mru_list_.begin(), key) + 1;
78  size_t tiles_per_view_limit;
79  if (num_of_active_views == 0)
80    tiles_per_view_limit = num_tiles_limit_;
81  else
82    tiles_per_view_limit = num_tiles_limit_ / num_of_active_views;
83  new_num_of_tiles = std::min(new_num_of_tiles, tiles_per_view_limit);
84  size_t new_total_allocated_tiles =
85      total_allocated_tiles_ - old_num_of_tiles + new_num_of_tiles;
86  // Has enough tiles to satisfy the request.
87  if (new_total_allocated_tiles <= num_tiles_limit_) {
88    total_allocated_tiles_ = new_total_allocated_tiles;
89    new_policy.num_resources_limit = new_num_of_tiles;
90    (*key)->SetMemoryPolicy(new_policy, false);
91    return;
92  }
93
94  // Does not have enough tiles. Now evict other clients' tiles.
95  size_t tiles_left = num_tiles_limit_ - total_allocated_tiles_;
96
97  size_t evicted_tiles =
98      Evict(new_total_allocated_tiles - num_tiles_limit_, key);
99  if (evicted_tiles >= new_total_allocated_tiles - num_tiles_limit_) {
100    new_total_allocated_tiles -= evicted_tiles;
101    total_allocated_tiles_ = new_total_allocated_tiles;
102    new_policy.num_resources_limit = new_num_of_tiles;
103    (*key)->SetMemoryPolicy(new_policy, false);
104    return;
105  } else {
106    total_allocated_tiles_ = num_tiles_limit_;
107    new_policy.num_resources_limit =
108        tiles_left + old_num_of_tiles + evicted_tiles;
109    (*key)->SetMemoryPolicy(new_policy, false);
110    return;
111  }
112}
113
114GlobalTileManager::Key GlobalTileManager::PushBack(
115    GlobalTileManagerClient* client) {
116  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
117  DCHECK(mru_list_.end() ==
118         std::find(mru_list_.begin(), mru_list_.end(), client));
119  mru_list_.push_back(client);
120  Key back = mru_list_.end();
121  back--;
122  return back;
123}
124
125void GlobalTileManager::DidUse(Key key) {
126  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
127  DCHECK(mru_list_.end() != key);
128
129  mru_list_.splice(mru_list_.begin(), mru_list_, key);
130}
131
132GlobalTileManager::GlobalTileManager()
133    : num_tiles_limit_(kNumTilesLimit), total_allocated_tiles_(0) {
134}
135
136GlobalTileManager::~GlobalTileManager() {
137}
138
139bool GlobalTileManager::IsConsistent() const {
140  size_t total_tiles = 0;
141  ListType::const_iterator it;
142  for (it = mru_list_.begin(); it != mru_list_.end(); it++) {
143    total_tiles += (*it)->GetMemoryPolicy().num_resources_limit;
144  }
145
146  bool is_consistent = (total_tiles <= num_tiles_limit_ &&
147                        total_tiles == total_allocated_tiles_);
148
149  return is_consistent;
150}
151
152}  // namespace webview
153