#include "base/logging.h"
#include "base/metrics/histogram.h"
#include "cc/debug/traced_value.h"
+#include "cc/resources/direct_raster_worker_pool.h"
#include "cc/resources/image_raster_worker_pool.h"
#include "cc/resources/pixel_buffer_raster_worker_pool.h"
+#include "cc/resources/raster_worker_pool_delegate.h"
#include "cc/resources/tile.h"
-#include "third_party/skia/include/core/SkCanvas.h"
#include "ui/gfx/rect_conversions.h"
namespace cc {
-
namespace {
// Memory limit policy works by mapping some bin states to the NEVER bin.
// Determine bin based on three categories of tiles: things we need now,
// things we need soon, and eventually.
inline ManagedTileBin BinFromTilePriority(const TilePriority& prio) {
- // The amount of time/pixels for which we want to have prepainting coverage.
- // Note: All very arbitrary constants: metric-based tuning is welcome!
- const float kPrepaintingWindowTimeSeconds = 1.0f;
const float kBackflingGuardDistancePixels = 314.0f;
- // Note: The max distances here assume that SOON_BIN will never help overcome
- // raster being too slow (only caching in advance will do that), so we just
- // need enough padding to handle some latency and per-tile variability.
- const float kMaxPrepaintingDistancePixelsHighRes = 2000.0f;
- const float kMaxPrepaintingDistancePixelsLowRes = 4000.0f;
-
- if (prio.distance_to_visible_in_pixels ==
- std::numeric_limits<float>::infinity())
- return NEVER_BIN;
- if (prio.time_to_visible_in_seconds == 0)
+ if (prio.priority_bin == TilePriority::NOW)
return NOW_BIN;
- if (prio.resolution == NON_IDEAL_RESOLUTION)
- return EVENTUALLY_BIN;
-
- float max_prepainting_distance_pixels =
- (prio.resolution == HIGH_RESOLUTION)
- ? kMaxPrepaintingDistancePixelsHighRes
- : kMaxPrepaintingDistancePixelsLowRes;
-
- // Soon bin if we are within backfling-guard, or under both the time window
- // and the max distance window.
- if (prio.distance_to_visible_in_pixels < kBackflingGuardDistancePixels ||
- (prio.time_to_visible_in_seconds < kPrepaintingWindowTimeSeconds &&
- prio.distance_to_visible_in_pixels <= max_prepainting_distance_pixels))
+ if (prio.priority_bin == TilePriority::SOON ||
+ prio.distance_to_visible < kBackflingGuardDistancePixels)
return SOON_BIN;
+ if (prio.distance_to_visible == std::numeric_limits<float>::infinity())
+ return NEVER_BIN;
+
return EVENTUALLY_BIN;
}
ContextProvider* context_provider,
RenderingStatsInstrumentation* rendering_stats_instrumentation,
bool use_map_image,
+ bool use_rasterize_on_demand,
size_t max_transfer_buffer_usage_bytes,
size_t max_raster_usage_bytes,
unsigned map_image_texture_target) {
return make_scoped_ptr(new TileManager(
client,
resource_provider,
- use_map_image
- ? ImageRasterWorkerPool::Create(
- resource_provider, context_provider, map_image_texture_target)
- : PixelBufferRasterWorkerPool::Create(
- resource_provider,
- context_provider,
- max_transfer_buffer_usage_bytes),
+ context_provider,
+ use_map_image ? ImageRasterWorkerPool::Create(resource_provider,
+ map_image_texture_target)
+ : PixelBufferRasterWorkerPool::Create(
+ resource_provider, max_transfer_buffer_usage_bytes),
+ DirectRasterWorkerPool::Create(resource_provider, context_provider),
max_raster_usage_bytes,
- rendering_stats_instrumentation));
+ rendering_stats_instrumentation,
+ use_rasterize_on_demand));
}
TileManager::TileManager(
TileManagerClient* client,
ResourceProvider* resource_provider,
+ ContextProvider* context_provider,
scoped_ptr<RasterWorkerPool> raster_worker_pool,
+ scoped_ptr<RasterWorkerPool> direct_raster_worker_pool,
size_t max_raster_usage_bytes,
- RenderingStatsInstrumentation* rendering_stats_instrumentation)
+ RenderingStatsInstrumentation* rendering_stats_instrumentation,
+ bool use_rasterize_on_demand)
: client_(client),
+ context_provider_(context_provider),
resource_pool_(
ResourcePool::Create(resource_provider,
raster_worker_pool->GetResourceTarget(),
raster_worker_pool->GetResourceFormat())),
raster_worker_pool_(raster_worker_pool.Pass()),
+ direct_raster_worker_pool_(direct_raster_worker_pool.Pass()),
prioritized_tiles_dirty_(false),
all_tiles_that_need_to_be_rasterized_have_memory_(true),
all_tiles_required_for_activation_have_memory_(true),
ever_exceeded_memory_budget_(false),
rendering_stats_instrumentation_(rendering_stats_instrumentation),
did_initialize_visible_tile_(false),
- did_check_for_completed_tasks_since_last_schedule_tasks_(true) {
- raster_worker_pool_->SetClient(this);
+ did_check_for_completed_tasks_since_last_schedule_tasks_(true),
+ use_rasterize_on_demand_(use_rasterize_on_demand) {
+ RasterWorkerPool* raster_worker_pools[NUM_RASTER_WORKER_POOL_TYPES] = {
+ raster_worker_pool_.get(), // RASTER_WORKER_POOL_TYPE_DEFAULT
+ direct_raster_worker_pool_.get() // RASTER_WORKER_POOL_TYPE_DIRECT
+ };
+ raster_worker_pool_delegate_ = RasterWorkerPoolDelegate::Create(
+ this, raster_worker_pools, arraysize(raster_worker_pools));
}
TileManager::~TileManager() {
CleanUpReleasedTiles();
DCHECK_EQ(0u, tiles_.size());
- RasterWorkerPool::RasterTask::Queue empty;
- raster_worker_pool_->ScheduleTasks(&empty);
+ RasterWorkerPool::RasterTask::Queue empty[NUM_RASTER_WORKER_POOL_TYPES];
+ raster_worker_pool_delegate_->ScheduleTasks(empty);
// This should finish all pending tasks and release any uninitialized
// resources.
- raster_worker_pool_->Shutdown();
- raster_worker_pool_->CheckForCompletedTasks();
+ raster_worker_pool_delegate_->Shutdown();
+ raster_worker_pool_delegate_->CheckForCompletedTasks();
DCHECK_EQ(0u, bytes_releasable_);
DCHECK_EQ(0u, resources_releasable_);
if (all_tiles_that_need_to_be_rasterized_have_memory_)
return;
- raster_worker_pool_->CheckForCompletedTasks();
+ raster_worker_pool_delegate_->CheckForCompletedTasks();
did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
TileVector tiles_that_need_to_be_rasterized;
// If we can't raster on demand, give up early (and don't activate).
if (!allow_rasterize_on_demand)
return;
- tile_version.set_rasterize_on_demand();
+ if (use_rasterize_on_demand_)
+ tile_version.set_rasterize_on_demand();
}
}
// Compute combined bin.
ManagedTileBin combined_bin = std::min(active_bin, pending_bin);
+ if (!tile_is_ready_to_draw || tile_version.requires_resource()) {
+ // The bin that the tile would have if the GPU memory manager had
+ // a maximally permissive policy, send to the GPU memory manager
+ // to determine policy.
+ ManagedTileBin gpu_memmgr_stats_bin = combined_bin;
+ if ((gpu_memmgr_stats_bin == NOW_BIN) ||
+ (gpu_memmgr_stats_bin == NOW_AND_READY_TO_DRAW_BIN))
+ memory_required_bytes_ += BytesConsumedIfAllocated(tile);
+ if (gpu_memmgr_stats_bin != NEVER_BIN)
+ memory_nice_to_have_bytes_ += BytesConsumedIfAllocated(tile);
+ }
+
ManagedTileBin tree_bin[NUM_TREES];
tree_bin[ACTIVE_TREE] = kBinPolicyMap[memory_policy][active_bin];
tree_bin[PENDING_TREE] = kBinPolicyMap[memory_policy][pending_bin];
- // The bin that the tile would have if the GPU memory manager had
- // a maximally permissive policy, send to the GPU memory manager
- // to determine policy.
- ManagedTileBin gpu_memmgr_stats_bin = NEVER_BIN;
TilePriority tile_priority;
-
switch (tree_priority) {
case SAME_PRIORITY_FOR_BOTH_TREES:
mts.bin = kBinPolicyMap[memory_policy][combined_bin];
- gpu_memmgr_stats_bin = combined_bin;
tile_priority = tile->combined_priority();
break;
case SMOOTHNESS_TAKES_PRIORITY:
mts.bin = tree_bin[ACTIVE_TREE];
- gpu_memmgr_stats_bin = active_bin;
tile_priority = active_priority;
break;
case NEW_CONTENT_TAKES_PRIORITY:
mts.bin = tree_bin[PENDING_TREE];
- gpu_memmgr_stats_bin = pending_bin;
tile_priority = pending_priority;
break;
}
- if (!tile_is_ready_to_draw || tile_version.requires_resource()) {
- if ((gpu_memmgr_stats_bin == NOW_BIN) ||
- (gpu_memmgr_stats_bin == NOW_AND_READY_TO_DRAW_BIN))
- memory_required_bytes_ += BytesConsumedIfAllocated(tile);
- if (gpu_memmgr_stats_bin != NEVER_BIN)
- memory_nice_to_have_bytes_ += BytesConsumedIfAllocated(tile);
- }
-
// Bump up the priority if we determined it's NEVER_BIN on one tree,
// but is still required on the other tree.
bool is_in_never_bin_on_both_trees = tree_bin[ACTIVE_TREE] == NEVER_BIN &&
mts.bin = tile_is_active ? AT_LAST_AND_ACTIVE_BIN : AT_LAST_BIN;
mts.resolution = tile_priority.resolution;
- mts.time_to_needed_in_seconds = tile_priority.time_to_visible_in_seconds;
- mts.distance_to_visible_in_pixels =
- tile_priority.distance_to_visible_in_pixels;
+ mts.priority_bin = tile_priority.priority_bin;
+ mts.distance_to_visible = tile_priority.distance_to_visible;
mts.required_for_activation = tile_priority.required_for_activation;
mts.visible_and_ready_to_draw =
continue;
}
- // Note that if the tile is visible_and_ready_to_draw, then we always want
- // the priority to be NOW_AND_READY_TO_DRAW_BIN, even if HIGH_PRIORITY_BIN
- // is something different. The reason for this is that if we're prioritizing
- // the pending tree, we still want visible tiles to take the highest
- // priority.
- ManagedTileBin priority_bin =
- mts.visible_and_ready_to_draw ? NOW_AND_READY_TO_DRAW_BIN : mts.bin;
+ // In almost all concievable cases (all in practice right now), we can't get
+ // memory back from visible-active-tree tiles. Further, active-tree tiles
+ // can still be used for animations. Further, ready-to-draw tiles won't
+ // delay activation since they are already rastered. So we should keep
+ // these tiles around in all cases.
+ if (mts.visible_and_ready_to_draw)
+ mts.bin = NOW_AND_READY_TO_DRAW_BIN;
// Insert the tile into a priority set.
- tiles->InsertTile(tile, priority_bin);
+ tiles->InsertTile(tile, mts.bin);
}
}
if (state != global_state_) {
global_state_ = state;
prioritized_tiles_dirty_ = true;
+ // Soft limit is used for resource pool such that
+ // memory returns to soft limit after going over.
resource_pool_->SetResourceUsageLimits(
- global_state_.memory_limit_in_bytes,
+ global_state_.soft_memory_limit_in_bytes,
global_state_.unused_memory_limit_in_bytes,
global_state_.num_resources_limit);
}
// We need to call CheckForCompletedTasks() once in-between each call
// to ScheduleTasks() to prevent canceled tasks from being scheduled.
if (!did_check_for_completed_tasks_since_last_schedule_tasks_) {
- raster_worker_pool_->CheckForCompletedTasks();
+ raster_worker_pool_delegate_->CheckForCompletedTasks();
did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
}
bool TileManager::UpdateVisibleTiles() {
TRACE_EVENT0("cc", "TileManager::UpdateVisibleTiles");
- raster_worker_pool_->CheckForCompletedTasks();
+ raster_worker_pool_delegate_->CheckForCompletedTasks();
did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
TRACE_EVENT_INSTANT1(
all_tiles_required_for_activation_have_memory_ = true;
// Cast to prevent overflow.
- int64 bytes_available =
+ int64 soft_bytes_available =
static_cast<int64>(bytes_releasable_) +
- static_cast<int64>(global_state_.memory_limit_in_bytes) -
+ static_cast<int64>(global_state_.soft_memory_limit_in_bytes) -
+ static_cast<int64>(resource_pool_->acquired_memory_usage_bytes());
+ int64 hard_bytes_available =
+ static_cast<int64>(bytes_releasable_) +
+ static_cast<int64>(global_state_.hard_memory_limit_in_bytes) -
static_cast<int64>(resource_pool_->acquired_memory_usage_bytes());
int resources_available = resources_releasable_ +
global_state_.num_resources_limit -
resource_pool_->acquired_resource_count();
-
- size_t bytes_allocatable = std::max(static_cast<int64>(0), bytes_available);
+ size_t soft_bytes_allocatable =
+ std::max(static_cast<int64>(0), soft_bytes_available);
+ size_t hard_bytes_allocatable =
+ std::max(static_cast<int64>(0), hard_bytes_available);
size_t resources_allocatable = std::max(0, resources_available);
size_t bytes_that_exceeded_memory_budget = 0;
- size_t bytes_left = bytes_allocatable;
+ size_t soft_bytes_left = soft_bytes_allocatable;
+ size_t hard_bytes_left = hard_bytes_allocatable;
+
size_t resources_left = resources_allocatable;
- bool oomed = false;
+ bool oomed_soft = false;
+ bool oomed_hard = false;
+ bool have_hit_soft_memory = false; // Soft memory comes after hard.
// Memory we assign to raster tasks now will be deducted from our memory
// in future iterations if priorities change. By assigning at most half
continue;
}
- size_t bytes_if_allocated = BytesConsumedIfAllocated(tile);
- size_t raster_bytes_if_rastered = raster_bytes + bytes_if_allocated;
+ const bool tile_uses_hard_limit = mts.bin <= NOW_BIN;
+ const size_t bytes_if_allocated = BytesConsumedIfAllocated(tile);
+ const size_t raster_bytes_if_rastered = raster_bytes + bytes_if_allocated;
+ const size_t tile_bytes_left =
+ (tile_uses_hard_limit) ? hard_bytes_left : soft_bytes_left;
+
+ // Hard-limit is reserved for tiles that would cause a calamity
+ // if they were to go away, so by definition they are the highest
+ // priority memory, and must be at the front of the list.
+ DCHECK(!(have_hit_soft_memory && tile_uses_hard_limit));
+ have_hit_soft_memory |= !tile_uses_hard_limit;
size_t tile_bytes = 0;
size_t tile_resources = 0;
}
// Tile is OOM.
- if (tile_bytes > bytes_left || tile_resources > resources_left) {
+ if (tile_bytes > tile_bytes_left || tile_resources > resources_left) {
FreeResourcesForTile(tile);
// This tile was already on screen and now its resources have been
// released. In order to prevent checkerboarding, set this tile as
// rasterize on demand immediately.
- if (mts.visible_and_ready_to_draw)
+ if (mts.visible_and_ready_to_draw && use_rasterize_on_demand_)
tile_version.set_rasterize_on_demand();
- oomed = true;
- bytes_that_exceeded_memory_budget += tile_bytes;
+ oomed_soft = true;
+ if (tile_uses_hard_limit) {
+ oomed_hard = true;
+ bytes_that_exceeded_memory_budget += tile_bytes;
+ }
} else {
- bytes_left -= tile_bytes;
resources_left -= tile_resources;
-
+ hard_bytes_left -= tile_bytes;
+ soft_bytes_left =
+ (soft_bytes_left > tile_bytes) ? soft_bytes_left - tile_bytes : 0;
if (tile_version.resource_)
continue;
}
// 1. Tile size should not impact raster priority.
// 2. Tiles with existing raster task could otherwise incorrectly
// be added as they are not affected by |bytes_allocatable|.
- if (oomed || raster_bytes_if_rastered > max_raster_bytes) {
+ if (oomed_soft || raster_bytes_if_rastered > max_raster_bytes) {
all_tiles_that_need_to_be_rasterized_have_memory_ = false;
if (tile->required_for_activation())
all_tiles_required_for_activation_have_memory_ = false;
tiles_that_need_to_be_rasterized->push_back(tile);
}
- ever_exceeded_memory_budget_ |= bytes_that_exceeded_memory_budget > 0;
+ // OOM reporting uses hard-limit, soft-OOM is normal depending on limit.
+ ever_exceeded_memory_budget_ |= oomed_hard;
if (ever_exceeded_memory_budget_) {
TRACE_COUNTER_ID2("cc",
"over_memory_budget",
this,
"budget",
- global_state_.memory_limit_in_bytes,
+ global_state_.hard_memory_limit_in_bytes,
"over",
bytes_that_exceeded_memory_budget);
}
memory_stats_from_last_assign_.total_budget_in_bytes =
- global_state_.memory_limit_in_bytes;
+ global_state_.hard_memory_limit_in_bytes;
memory_stats_from_last_assign_.bytes_allocated =
- bytes_allocatable - bytes_left;
+ hard_bytes_allocatable - hard_bytes_left;
memory_stats_from_last_assign_.bytes_unreleasable =
- bytes_allocatable - bytes_releasable_;
+ hard_bytes_allocatable - bytes_releasable_;
memory_stats_from_last_assign_.bytes_over = bytes_that_exceeded_memory_budget;
}
"TileManager::ScheduleTasks",
"count",
tiles_that_need_to_be_rasterized.size());
- RasterWorkerPool::RasterTask::Queue tasks;
DCHECK(did_check_for_completed_tasks_since_last_schedule_tasks_);
+ for (size_t i = 0; i < NUM_RASTER_WORKER_POOL_TYPES; ++i)
+ raster_queue_[i].Reset();
+
// Build a new task queue containing all task currently needed. Tasks
// are added in order of priority, highest priority task first.
for (TileVector::const_iterator it = tiles_that_need_to_be_rasterized.begin();
if (tile_version.raster_task_.is_null())
tile_version.raster_task_ = CreateRasterTask(tile);
- tasks.Append(tile_version.raster_task_, tile->required_for_activation());
+ size_t pool_type = tile->use_gpu_rasterization()
+ ? RASTER_WORKER_POOL_TYPE_DIRECT
+ : RASTER_WORKER_POOL_TYPE_DEFAULT;
+
+ raster_queue_[pool_type]
+ .Append(tile_version.raster_task_, tile->required_for_activation());
}
// We must reduce the amount of unused resoruces before calling
// ScheduleTasks to prevent usage from rising above limits.
resource_pool_->ReduceResourceUsage();
- // Schedule running of |tasks|. This replaces any previously
+ // Schedule running of |raster_tasks_|. This replaces any previously
// scheduled tasks and effectively cancels all tasks not present
- // in |tasks|.
- raster_worker_pool_->ScheduleTasks(&tasks);
+ // in |raster_tasks_|.
+ raster_worker_pool_delegate_->ScheduleTasks(raster_queue_);
did_check_for_completed_tasks_since_last_schedule_tasks_ = false;
}
tile->layer_id(),
static_cast<const void*>(tile),
tile->source_frame_number(),
- tile->use_gpu_rasterization(),
rendering_stats_instrumentation_,
base::Bind(&TileManager::OnRasterTaskCompleted,
base::Unretained(this),
tile->id(),
base::Passed(&resource),
mts.raster_mode),
- &decode_tasks);
+ &decode_tasks,
+ context_provider_);
}
void TileManager::OnImageDecodeTaskCompleted(int layer_id,
}
FreeUnusedResourcesForTile(tile);
- if (tile->priority(ACTIVE_TREE).distance_to_visible_in_pixels == 0)
+ if (tile->priority(ACTIVE_TREE).distance_to_visible == 0.f)
did_initialize_visible_tile_ = true;
}
scoped_refptr<Tile> TileManager::CreateTile(PicturePileImpl* picture_pile,
- gfx::Size tile_size,
+ const gfx::Size& tile_size,
const gfx::Rect& content_rect,
const gfx::Rect& opaque_rect,
float contents_scale,
projects / platform / framework / web / crosswalk.git / blobdiff