Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(197)

Side by Side Diff: cc/resources/tile_manager.cc

Issue 246673005: cc: Start using raster/eviction iterators in tile manager (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: Created 6 years, 6 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
OLDNEW
1 // Copyright 2012 The Chromium Authors. All rights reserved. 1 // Copyright 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be 2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file. 3 // found in the LICENSE file.
4 4
5 #include "cc/resources/tile_manager.h" 5 #include "cc/resources/tile_manager.h"
6 6
7 #include <algorithm> 7 #include <algorithm>
8 #include <limits> 8 #include <limits>
9 #include <string> 9 #include <string>
10 10
(...skipping 209 matching lines...) Expand 10 before | Expand all | Expand 10 after
220 skia::RefPtr<SkPixelRef> pixel_ref_; 220 skia::RefPtr<SkPixelRef> pixel_ref_;
221 int layer_id_; 221 int layer_id_;
222 RenderingStatsInstrumentation* rendering_stats_; 222 RenderingStatsInstrumentation* rendering_stats_;
223 const base::Callback<void(bool was_canceled)> reply_; 223 const base::Callback<void(bool was_canceled)> reply_;
224 224
225 DISALLOW_COPY_AND_ASSIGN(ImageDecodeTaskImpl); 225 DISALLOW_COPY_AND_ASSIGN(ImageDecodeTaskImpl);
226 }; 226 };
227 227
228 const size_t kScheduledRasterTasksLimit = 32u; 228 const size_t kScheduledRasterTasksLimit = 32u;
229 229
230 // Memory limit policy works by mapping some bin states to the NEVER bin.
231 const ManagedTileBin kBinPolicyMap[NUM_TILE_MEMORY_LIMIT_POLICIES][NUM_BINS] = {
232 // [ALLOW_NOTHING]
233 {NEVER_BIN, // [NOW_AND_READY_TO_DRAW_BIN]
234 NEVER_BIN, // [NOW_BIN]
235 NEVER_BIN, // [SOON_BIN]
236 NEVER_BIN, // [EVENTUALLY_AND_ACTIVE_BIN]
237 NEVER_BIN, // [EVENTUALLY_BIN]
238 NEVER_BIN, // [AT_LAST_AND_ACTIVE_BIN]
239 NEVER_BIN, // [AT_LAST_BIN]
240 NEVER_BIN // [NEVER_BIN]
241 },
242 // [ALLOW_ABSOLUTE_MINIMUM]
243 {NOW_AND_READY_TO_DRAW_BIN, // [NOW_AND_READY_TO_DRAW_BIN]
244 NOW_BIN, // [NOW_BIN]
245 NEVER_BIN, // [SOON_BIN]
246 NEVER_BIN, // [EVENTUALLY_AND_ACTIVE_BIN]
247 NEVER_BIN, // [EVENTUALLY_BIN]
248 NEVER_BIN, // [AT_LAST_AND_ACTIVE_BIN]
249 NEVER_BIN, // [AT_LAST_BIN]
250 NEVER_BIN // [NEVER_BIN]
251 },
252 // [ALLOW_PREPAINT_ONLY]
253 {NOW_AND_READY_TO_DRAW_BIN, // [NOW_AND_READY_TO_DRAW_BIN]
254 NOW_BIN, // [NOW_BIN]
255 SOON_BIN, // [SOON_BIN]
256 NEVER_BIN, // [EVENTUALLY_AND_ACTIVE_BIN]
257 NEVER_BIN, // [EVENTUALLY_BIN]
258 NEVER_BIN, // [AT_LAST_AND_ACTIVE_BIN]
259 NEVER_BIN, // [AT_LAST_BIN]
260 NEVER_BIN // [NEVER_BIN]
261 },
262 // [ALLOW_ANYTHING]
263 {NOW_AND_READY_TO_DRAW_BIN, // [NOW_AND_READY_TO_DRAW_BIN]
264 NOW_BIN, // [NOW_BIN]
265 SOON_BIN, // [SOON_BIN]
266 EVENTUALLY_AND_ACTIVE_BIN, // [EVENTUALLY_AND_ACTIVE_BIN]
267 EVENTUALLY_BIN, // [EVENTUALLY_BIN]
268 AT_LAST_AND_ACTIVE_BIN, // [AT_LAST_AND_ACTIVE_BIN]
269 AT_LAST_BIN, // [AT_LAST_BIN]
270 NEVER_BIN // [NEVER_BIN]
271 }};
272
273 // Ready to draw works by mapping NOW_BIN to NOW_AND_READY_TO_DRAW_BIN.
274 const ManagedTileBin kBinReadyToDrawMap[2][NUM_BINS] = {
275 // Not ready
276 {NOW_AND_READY_TO_DRAW_BIN, // [NOW_AND_READY_TO_DRAW_BIN]
277 NOW_BIN, // [NOW_BIN]
278 SOON_BIN, // [SOON_BIN]
279 EVENTUALLY_AND_ACTIVE_BIN, // [EVENTUALLY_AND_ACTIVE_BIN]
280 EVENTUALLY_BIN, // [EVENTUALLY_BIN]
281 AT_LAST_AND_ACTIVE_BIN, // [AT_LAST_AND_ACTIVE_BIN]
282 AT_LAST_BIN, // [AT_LAST_BIN]
283 NEVER_BIN // [NEVER_BIN]
284 },
285 // Ready
286 {NOW_AND_READY_TO_DRAW_BIN, // [NOW_AND_READY_TO_DRAW_BIN]
287 NOW_AND_READY_TO_DRAW_BIN, // [NOW_BIN]
288 SOON_BIN, // [SOON_BIN]
289 EVENTUALLY_AND_ACTIVE_BIN, // [EVENTUALLY_AND_ACTIVE_BIN]
290 EVENTUALLY_BIN, // [EVENTUALLY_BIN]
291 AT_LAST_AND_ACTIVE_BIN, // [AT_LAST_AND_ACTIVE_BIN]
292 AT_LAST_BIN, // [AT_LAST_BIN]
293 NEVER_BIN // [NEVER_BIN]
294 }};
295
296 // Active works by mapping some bin stats to equivalent _ACTIVE_BIN state.
297 const ManagedTileBin kBinIsActiveMap[2][NUM_BINS] = {
298 // Inactive
299 {NOW_AND_READY_TO_DRAW_BIN, // [NOW_AND_READY_TO_DRAW_BIN]
300 NOW_BIN, // [NOW_BIN]
301 SOON_BIN, // [SOON_BIN]
302 EVENTUALLY_AND_ACTIVE_BIN, // [EVENTUALLY_AND_ACTIVE_BIN]
303 EVENTUALLY_BIN, // [EVENTUALLY_BIN]
304 AT_LAST_AND_ACTIVE_BIN, // [AT_LAST_AND_ACTIVE_BIN]
305 AT_LAST_BIN, // [AT_LAST_BIN]
306 NEVER_BIN // [NEVER_BIN]
307 },
308 // Active
309 {NOW_AND_READY_TO_DRAW_BIN, // [NOW_AND_READY_TO_DRAW_BIN]
310 NOW_BIN, // [NOW_BIN]
311 SOON_BIN, // [SOON_BIN]
312 EVENTUALLY_AND_ACTIVE_BIN, // [EVENTUALLY_AND_ACTIVE_BIN]
313 EVENTUALLY_AND_ACTIVE_BIN, // [EVENTUALLY_BIN]
314 AT_LAST_AND_ACTIVE_BIN, // [AT_LAST_AND_ACTIVE_BIN]
315 AT_LAST_AND_ACTIVE_BIN, // [AT_LAST_BIN]
316 NEVER_BIN // [NEVER_BIN]
317 }};
318
319 // Determine bin based on three categories of tiles: things we need now,
320 // things we need soon, and eventually.
321 inline ManagedTileBin BinFromTilePriority(const TilePriority& prio) {
322 if (prio.priority_bin == TilePriority::NOW)
323 return NOW_BIN;
324
325 if (prio.priority_bin == TilePriority::SOON)
326 return SOON_BIN;
327
328 if (prio.distance_to_visible == std::numeric_limits<float>::infinity())
329 return NEVER_BIN;
330
331 return EVENTUALLY_BIN;
332 }
333
334 } // namespace 230 } // namespace
335 231
336 RasterTaskCompletionStats::RasterTaskCompletionStats() 232 RasterTaskCompletionStats::RasterTaskCompletionStats()
337 : completed_count(0u), canceled_count(0u) {} 233 : completed_count(0u), canceled_count(0u) {}
338 234
339 scoped_ptr<base::Value> RasterTaskCompletionStatsAsValue( 235 scoped_ptr<base::Value> RasterTaskCompletionStatsAsValue(
340 const RasterTaskCompletionStats& stats) { 236 const RasterTaskCompletionStats& stats) {
341 scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue()); 237 scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue());
342 state->SetInteger("completed_count", stats.completed_count); 238 state->SetInteger("completed_count", stats.completed_count);
343 state->SetInteger("canceled_count", stats.canceled_count); 239 state->SetInteger("canceled_count", stats.canceled_count);
(...skipping 17 matching lines...) Expand all
361 TileManager::TileManager( 257 TileManager::TileManager(
362 TileManagerClient* client, 258 TileManagerClient* client,
363 base::SequencedTaskRunner* task_runner, 259 base::SequencedTaskRunner* task_runner,
364 ResourcePool* resource_pool, 260 ResourcePool* resource_pool,
365 Rasterizer* rasterizer, 261 Rasterizer* rasterizer,
366 RenderingStatsInstrumentation* rendering_stats_instrumentation) 262 RenderingStatsInstrumentation* rendering_stats_instrumentation)
367 : client_(client), 263 : client_(client),
368 task_runner_(task_runner), 264 task_runner_(task_runner),
369 resource_pool_(resource_pool), 265 resource_pool_(resource_pool),
370 rasterizer_(rasterizer), 266 rasterizer_(rasterizer),
371 prioritized_tiles_dirty_(false),
372 all_tiles_that_need_to_be_rasterized_have_memory_(true), 267 all_tiles_that_need_to_be_rasterized_have_memory_(true),
373 all_tiles_required_for_activation_have_memory_(true),
374 memory_required_bytes_(0),
375 memory_nice_to_have_bytes_(0),
376 bytes_releasable_(0),
377 resources_releasable_(0),
378 ever_exceeded_memory_budget_(false), 268 ever_exceeded_memory_budget_(false),
379 rendering_stats_instrumentation_(rendering_stats_instrumentation), 269 rendering_stats_instrumentation_(rendering_stats_instrumentation),
380 did_initialize_visible_tile_(false), 270 did_initialize_visible_tile_(false),
381 did_check_for_completed_tasks_since_last_schedule_tasks_(true), 271 did_check_for_completed_tasks_since_last_schedule_tasks_(true),
382 ready_to_activate_check_notifier_( 272 ready_to_activate_check_notifier_(
383 task_runner_, 273 task_runner_,
384 base::Bind(&TileManager::CheckIfReadyToActivate, 274 base::Bind(&TileManager::CheckIfReadyToActivate,
385 base::Unretained(this))) { 275 base::Unretained(this))) {
386 rasterizer_->SetClient(this); 276 rasterizer_->SetClient(this);
387 } 277 }
388 278
389 TileManager::~TileManager() { 279 TileManager::~TileManager() {
390 // Reset global state and manage. This should cause 280 // Reset global state and manage. This should cause
391 // our memory usage to drop to zero. 281 // our memory usage to drop to zero.
392 global_state_ = GlobalStateThatImpactsTilePriority(); 282 global_state_ = GlobalStateThatImpactsTilePriority();
393 283
394 CleanUpReleasedTiles(); 284 CleanUpReleasedTiles();
395 DCHECK_EQ(0u, tiles_.size()); 285 DCHECK_EQ(0u, tiles_.size());
396 286
397 RasterTaskQueue empty; 287 RasterTaskQueue empty;
398 rasterizer_->ScheduleTasks(&empty); 288 rasterizer_->ScheduleTasks(&empty);
399 orphan_raster_tasks_.clear(); 289 orphan_raster_tasks_.clear();
400 290
401 // This should finish all pending tasks and release any uninitialized 291 // This should finish all pending tasks and release any uninitialized
402 // resources. 292 // resources.
403 rasterizer_->Shutdown(); 293 rasterizer_->Shutdown();
404 rasterizer_->CheckForCompletedTasks(); 294 rasterizer_->CheckForCompletedTasks();
405
406 DCHECK_EQ(0u, bytes_releasable_);
407 DCHECK_EQ(0u, resources_releasable_);
408 } 295 }
409 296
410 void TileManager::Release(Tile* tile) { 297 void TileManager::Release(Tile* tile) {
411 prioritized_tiles_dirty_ = true;
412 released_tiles_.push_back(tile); 298 released_tiles_.push_back(tile);
413 } 299 }
414 300
415 void TileManager::DidChangeTilePriority(Tile* tile) {
416 prioritized_tiles_dirty_ = true;
417 }
418
419 bool TileManager::ShouldForceTasksRequiredForActivationToComplete() const { 301 bool TileManager::ShouldForceTasksRequiredForActivationToComplete() const {
420 return global_state_.tree_priority != SMOOTHNESS_TAKES_PRIORITY; 302 return global_state_.tree_priority != SMOOTHNESS_TAKES_PRIORITY;
421 } 303 }
422 304
423 void TileManager::CleanUpReleasedTiles() { 305 void TileManager::CleanUpReleasedTiles() {
424 for (std::vector<Tile*>::iterator it = released_tiles_.begin(); 306 for (std::vector<Tile*>::iterator it = released_tiles_.begin();
425 it != released_tiles_.end(); 307 it != released_tiles_.end();
426 ++it) { 308 ++it) {
reveman 2014/06/18 03:35:42 Completely unrelated. How about we only release ti
vmpstr 2014/06/18 06:45:00 That sounds good. Filed crbug.com/386039
reveman 2014/06/18 16:41:09 Thanks!
427 Tile* tile = *it; 309 Tile* tile = *it;
428 ManagedTileState& mts = tile->managed_state(); 310 ManagedTileState& mts = tile->managed_state();
429 311
430 for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) { 312 for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) {
431 FreeResourceForTile(tile, static_cast<RasterMode>(mode)); 313 FreeResourceForTile(tile, static_cast<RasterMode>(mode));
432 orphan_raster_tasks_.push_back(mts.tile_versions[mode].raster_task_); 314 orphan_raster_tasks_.push_back(mts.tile_versions[mode].raster_task_);
433 } 315 }
434 316
435 DCHECK(tiles_.find(tile->id()) != tiles_.end()); 317 DCHECK(tiles_.find(tile->id()) != tiles_.end());
436 tiles_.erase(tile->id()); 318 tiles_.erase(tile->id());
437 319
438 LayerCountMap::iterator layer_it = 320 LayerCountMap::iterator layer_it =
439 used_layer_counts_.find(tile->layer_id()); 321 used_layer_counts_.find(tile->layer_id());
440 DCHECK_GT(layer_it->second, 0); 322 DCHECK_GT(layer_it->second, 0);
441 if (--layer_it->second == 0) { 323 if (--layer_it->second == 0) {
442 used_layer_counts_.erase(layer_it); 324 used_layer_counts_.erase(layer_it);
443 image_decode_tasks_.erase(tile->layer_id()); 325 image_decode_tasks_.erase(tile->layer_id());
444 } 326 }
445 327
446 delete tile; 328 delete tile;
447 } 329 }
448 330
449 released_tiles_.clear(); 331 released_tiles_.clear();
450 } 332 }
451 333
452 void TileManager::UpdatePrioritizedTileSetIfNeeded() {
453 if (!prioritized_tiles_dirty_)
454 return;
455
456 CleanUpReleasedTiles();
457
458 prioritized_tiles_.Clear();
459 GetTilesWithAssignedBins(&prioritized_tiles_);
460 prioritized_tiles_dirty_ = false;
461 }
462
463 void TileManager::DidFinishRunningTasks() { 334 void TileManager::DidFinishRunningTasks() {
464 TRACE_EVENT0("cc", "TileManager::DidFinishRunningTasks"); 335 TRACE_EVENT0("cc", "TileManager::DidFinishRunningTasks");
465 336
466 bool memory_usage_above_limit = resource_pool_->total_memory_usage_bytes() > 337 bool memory_usage_above_limit = resource_pool_->total_memory_usage_bytes() >
467 global_state_.soft_memory_limit_in_bytes; 338 global_state_.soft_memory_limit_in_bytes;
468 339
469 // When OOM, keep re-assigning memory until we reach a steady state 340 // When OOM, keep re-assigning memory until we reach a steady state
470 // where top-priority tiles are initialized. 341 // where top-priority tiles are initialized.
471 if (all_tiles_that_need_to_be_rasterized_have_memory_ && 342 if (all_tiles_that_need_to_be_rasterized_have_memory_ &&
472 !memory_usage_above_limit) 343 !memory_usage_above_limit)
473 return; 344 return;
474 345
475 rasterizer_->CheckForCompletedTasks(); 346 rasterizer_->CheckForCompletedTasks();
476 did_check_for_completed_tasks_since_last_schedule_tasks_ = true; 347 did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
477 348
478 TileVector tiles_that_need_to_be_rasterized; 349 TileVector tiles_that_need_to_be_rasterized;
479 AssignGpuMemoryToTiles(&prioritized_tiles_, 350 AssignGpuMemoryToTiles(&tiles_that_need_to_be_rasterized);
480 &tiles_that_need_to_be_rasterized);
481 351
482 // |tiles_that_need_to_be_rasterized| will be empty when we reach a 352 // |tiles_that_need_to_be_rasterized| will be empty when we reach a
483 // steady memory state. Keep scheduling tasks until we reach this state. 353 // steady memory state. Keep scheduling tasks until we reach this state.
484 if (!tiles_that_need_to_be_rasterized.empty()) { 354 if (!tiles_that_need_to_be_rasterized.empty()) {
485 ScheduleTasks(tiles_that_need_to_be_rasterized); 355 ScheduleTasks(tiles_that_need_to_be_rasterized);
486 return; 356 return;
487 } 357 }
488 358
489 resource_pool_->ReduceResourceUsage(); 359 resource_pool_->ReduceResourceUsage();
490 360
(...skipping 20 matching lines...) Expand all
511 tile_version.set_rasterize_on_demand(); 381 tile_version.set_rasterize_on_demand();
512 client_->NotifyTileStateChanged(tile); 382 client_->NotifyTileStateChanged(tile);
513 } 383 }
514 } 384 }
515 385
516 DCHECK(IsReadyToActivate()); 386 DCHECK(IsReadyToActivate());
517 ready_to_activate_check_notifier_.Schedule(); 387 ready_to_activate_check_notifier_.Schedule();
518 } 388 }
519 389
520 void TileManager::DidFinishRunningTasksRequiredForActivation() { 390 void TileManager::DidFinishRunningTasksRequiredForActivation() {
521 // This is only a true indication that all tiles required for
522 // activation are initialized when no tiles are OOM. We need to
523 // wait for DidFinishRunningTasks() to be called, try to re-assign
524 // memory and in worst case use on-demand raster when tiles
525 // required for activation are OOM.
526 if (!all_tiles_required_for_activation_have_memory_)
527 return;
528
529 ready_to_activate_check_notifier_.Schedule(); 391 ready_to_activate_check_notifier_.Schedule();
530 } 392 }
531 393
532 void TileManager::GetTilesWithAssignedBins(PrioritizedTileSet* tiles) {
533 TRACE_EVENT0("cc", "TileManager::GetTilesWithAssignedBins");
534
535 // Compute new stats to be return by GetMemoryStats().
536 memory_required_bytes_ = 0;
537 memory_nice_to_have_bytes_ = 0;
538
539 const TileMemoryLimitPolicy memory_policy = global_state_.memory_limit_policy;
540 const TreePriority tree_priority = global_state_.tree_priority;
541
542 // For each tree, bin into different categories of tiles.
543 for (TileMap::const_iterator it = tiles_.begin(); it != tiles_.end(); ++it) {
544 Tile* tile = it->second;
545 ManagedTileState& mts = tile->managed_state();
546
547 const ManagedTileState::TileVersion& tile_version =
548 tile->GetTileVersionForDrawing();
549 bool tile_is_ready_to_draw = tile_version.IsReadyToDraw();
550 bool tile_is_active = tile_is_ready_to_draw ||
551 mts.tile_versions[mts.raster_mode].raster_task_;
552
553 // Get the active priority and bin.
554 TilePriority active_priority = tile->priority(ACTIVE_TREE);
555 ManagedTileBin active_bin = BinFromTilePriority(active_priority);
556
557 // Get the pending priority and bin.
558 TilePriority pending_priority = tile->priority(PENDING_TREE);
559 ManagedTileBin pending_bin = BinFromTilePriority(pending_priority);
560
561 bool pending_is_low_res = pending_priority.resolution == LOW_RESOLUTION;
562 bool pending_is_non_ideal =
563 pending_priority.resolution == NON_IDEAL_RESOLUTION;
564 bool active_is_non_ideal =
565 active_priority.resolution == NON_IDEAL_RESOLUTION;
566
567 // Adjust bin state based on if ready to draw.
568 active_bin = kBinReadyToDrawMap[tile_is_ready_to_draw][active_bin];
569 pending_bin = kBinReadyToDrawMap[tile_is_ready_to_draw][pending_bin];
570
571 // Adjust bin state based on if active.
572 active_bin = kBinIsActiveMap[tile_is_active][active_bin];
573 pending_bin = kBinIsActiveMap[tile_is_active][pending_bin];
574
575 // We never want to paint new non-ideal tiles, as we always have
576 // a high-res tile covering that content (paint that instead).
577 if (!tile_is_ready_to_draw && active_is_non_ideal)
578 active_bin = NEVER_BIN;
579 if (!tile_is_ready_to_draw && pending_is_non_ideal)
580 pending_bin = NEVER_BIN;
581
582 if (!tile_is_ready_to_draw || tile_version.requires_resource()) {
583 // The bin that the tile would have if the GPU memory manager had
584 // a maximally permissive policy, send to the GPU memory manager
585 // to determine policy.
586 ManagedTileBin gpu_memmgr_stats_bin = std::min(active_bin, pending_bin);
587 if ((gpu_memmgr_stats_bin == NOW_BIN) ||
588 (gpu_memmgr_stats_bin == NOW_AND_READY_TO_DRAW_BIN))
589 memory_required_bytes_ += BytesConsumedIfAllocated(tile);
590 if (gpu_memmgr_stats_bin != NEVER_BIN)
591 memory_nice_to_have_bytes_ += BytesConsumedIfAllocated(tile);
592 }
593
594 ManagedTileBin tree_bin[NUM_TREES];
595 tree_bin[ACTIVE_TREE] = kBinPolicyMap[memory_policy][active_bin];
596 tree_bin[PENDING_TREE] = kBinPolicyMap[memory_policy][pending_bin];
597
598 // Adjust pending bin state for low res tiles. This prevents pending tree
599 // low-res tiles from being initialized before high-res tiles.
600 if (pending_is_low_res)
601 tree_bin[PENDING_TREE] = std::max(tree_bin[PENDING_TREE], EVENTUALLY_BIN);
602
603 TilePriority tile_priority;
604 switch (tree_priority) {
605 case SAME_PRIORITY_FOR_BOTH_TREES:
606 mts.bin = std::min(tree_bin[ACTIVE_TREE], tree_bin[PENDING_TREE]);
607 tile_priority = tile->combined_priority();
608 break;
609 case SMOOTHNESS_TAKES_PRIORITY:
610 mts.bin = tree_bin[ACTIVE_TREE];
611 tile_priority = active_priority;
612 break;
613 case NEW_CONTENT_TAKES_PRIORITY:
614 mts.bin = tree_bin[PENDING_TREE];
615 tile_priority = pending_priority;
616 break;
617 }
618
619 // Bump up the priority if we determined it's NEVER_BIN on one tree,
620 // but is still required on the other tree.
621 bool is_in_never_bin_on_both_trees = tree_bin[ACTIVE_TREE] == NEVER_BIN &&
622 tree_bin[PENDING_TREE] == NEVER_BIN;
623
624 if (mts.bin == NEVER_BIN && !is_in_never_bin_on_both_trees)
625 mts.bin = tile_is_active ? AT_LAST_AND_ACTIVE_BIN : AT_LAST_BIN;
626
627 mts.resolution = tile_priority.resolution;
628 mts.priority_bin = tile_priority.priority_bin;
629 mts.distance_to_visible = tile_priority.distance_to_visible;
630 mts.required_for_activation = tile_priority.required_for_activation;
631
632 mts.visible_and_ready_to_draw =
633 tree_bin[ACTIVE_TREE] == NOW_AND_READY_TO_DRAW_BIN;
634
635 // Tiles that are required for activation shouldn't be in NEVER_BIN unless
636 // smoothness takes priority or memory policy allows nothing to be
637 // initialized.
638 DCHECK(!mts.required_for_activation || mts.bin != NEVER_BIN ||
639 tree_priority == SMOOTHNESS_TAKES_PRIORITY ||
640 memory_policy == ALLOW_NOTHING);
641
642 // If the tile is in NEVER_BIN and it does not have an active task, then we
643 // can release the resources early. If it does have the task however, we
644 // should keep it in the prioritized tile set to ensure that AssignGpuMemory
645 // can visit it.
646 if (mts.bin == NEVER_BIN &&
647 !mts.tile_versions[mts.raster_mode].raster_task_) {
648 FreeResourcesForTileAndNotifyClientIfTileWasReadyToDraw(tile);
649 continue;
650 }
651
652 // Insert the tile into a priority set.
653 tiles->InsertTile(tile, mts.bin);
654 }
655 }
656
657 void TileManager::ManageTiles(const GlobalStateThatImpactsTilePriority& state) { 394 void TileManager::ManageTiles(const GlobalStateThatImpactsTilePriority& state) {
658 TRACE_EVENT0("cc", "TileManager::ManageTiles"); 395 TRACE_EVENT0("cc", "TileManager::ManageTiles");
659 396
660 // Update internal state. 397 // Update internal state.
reveman 2014/06/18 03:35:42 Silly comment. Keep it if you like but I don't min
vmpstr 2014/06/18 06:45:00 Removed.
661 if (state != global_state_) { 398 global_state_ = state;
662 global_state_ = state; 399
663 prioritized_tiles_dirty_ = true; 400 // TODO(vmpstr): See if we still need to keep tiles alive when layers release
664 } 401 // them.
402 CleanUpReleasedTiles();
reveman 2014/06/18 03:35:42 Note: we should instead call this after CheckForCo
vmpstr 2014/06/18 06:45:00 I've moved it. The previous code would effectively
665 403
666 // We need to call CheckForCompletedTasks() once in-between each call 404 // We need to call CheckForCompletedTasks() once in-between each call
667 // to ScheduleTasks() to prevent canceled tasks from being scheduled. 405 // to ScheduleTasks() to prevent canceled tasks from being scheduled.
668 if (!did_check_for_completed_tasks_since_last_schedule_tasks_) { 406 if (!did_check_for_completed_tasks_since_last_schedule_tasks_) {
669 rasterizer_->CheckForCompletedTasks(); 407 rasterizer_->CheckForCompletedTasks();
670 did_check_for_completed_tasks_since_last_schedule_tasks_ = true; 408 did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
671 } 409 }
672 410
673 UpdatePrioritizedTileSetIfNeeded();
674
675 TileVector tiles_that_need_to_be_rasterized; 411 TileVector tiles_that_need_to_be_rasterized;
676 AssignGpuMemoryToTiles(&prioritized_tiles_, 412 AssignGpuMemoryToTiles(&tiles_that_need_to_be_rasterized);
677 &tiles_that_need_to_be_rasterized);
678 413
679 // Finally, schedule rasterizer tasks. 414 // Finally, schedule rasterizer tasks.
680 ScheduleTasks(tiles_that_need_to_be_rasterized); 415 ScheduleTasks(tiles_that_need_to_be_rasterized);
681 416
682 TRACE_EVENT_INSTANT1("cc", 417 TRACE_EVENT_INSTANT1("cc",
683 "DidManage", 418 "DidManage",
684 TRACE_EVENT_SCOPE_THREAD, 419 TRACE_EVENT_SCOPE_THREAD,
685 "state", 420 "state",
686 TracedValue::FromValue(BasicStateAsValue().release())); 421 TracedValue::FromValue(BasicStateAsValue().release()));
687 422
(...skipping 21 matching lines...) Expand all
709 444
710 bool did_initialize_visible_tile = did_initialize_visible_tile_; 445 bool did_initialize_visible_tile = did_initialize_visible_tile_;
711 did_initialize_visible_tile_ = false; 446 did_initialize_visible_tile_ = false;
712 return did_initialize_visible_tile; 447 return did_initialize_visible_tile;
713 } 448 }
714 449
715 void TileManager::GetMemoryStats(size_t* memory_required_bytes, 450 void TileManager::GetMemoryStats(size_t* memory_required_bytes,
716 size_t* memory_nice_to_have_bytes, 451 size_t* memory_nice_to_have_bytes,
717 size_t* memory_allocated_bytes, 452 size_t* memory_allocated_bytes,
718 size_t* memory_used_bytes) const { 453 size_t* memory_used_bytes) const {
719 *memory_required_bytes = memory_required_bytes_; 454 // TODO(vmpstr): Remove this function.
vmpstr 2014/06/17 23:48:18 I'll try and remove this in parallel with this pat
reveman 2014/06/18 03:35:42 Great! Please remove the function in this or a sep
vmpstr 2014/06/18 06:45:00 That's here https://codereview.chromium.org/342483
720 *memory_nice_to_have_bytes = memory_nice_to_have_bytes_; 455 *memory_required_bytes = 0;
721 *memory_allocated_bytes = resource_pool_->total_memory_usage_bytes(); 456 *memory_nice_to_have_bytes = 0;
722 *memory_used_bytes = resource_pool_->acquired_memory_usage_bytes(); 457 *memory_allocated_bytes = 0;
458 *memory_used_bytes = 0;
723 } 459 }
724 460
725 scoped_ptr<base::Value> TileManager::BasicStateAsValue() const { 461 scoped_ptr<base::Value> TileManager::BasicStateAsValue() const {
726 scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue()); 462 scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue());
727 state->SetInteger("tile_count", tiles_.size()); 463 state->SetInteger("tile_count", tiles_.size());
728 state->Set("global_state", global_state_.AsValue().release()); 464 state->Set("global_state", global_state_.AsValue().release());
729 state->Set("memory_requirements", GetMemoryRequirementsAsValue().release()); 465 state->Set("memory_requirements", GetMemoryRequirementsAsValue().release());
730 return state.PassAs<base::Value>(); 466 return state.PassAs<base::Value>();
731 } 467 }
732 468
(...skipping 17 matching lines...) Expand all
750 &memory_allocated_bytes, 486 &memory_allocated_bytes,
751 &memory_used_bytes); 487 &memory_used_bytes);
752 requirements->SetInteger("memory_required_bytes", memory_required_bytes); 488 requirements->SetInteger("memory_required_bytes", memory_required_bytes);
753 requirements->SetInteger("memory_nice_to_have_bytes", 489 requirements->SetInteger("memory_nice_to_have_bytes",
754 memory_nice_to_have_bytes); 490 memory_nice_to_have_bytes);
755 requirements->SetInteger("memory_allocated_bytes", memory_allocated_bytes); 491 requirements->SetInteger("memory_allocated_bytes", memory_allocated_bytes);
756 requirements->SetInteger("memory_used_bytes", memory_used_bytes); 492 requirements->SetInteger("memory_used_bytes", memory_used_bytes);
757 return requirements.PassAs<base::Value>(); 493 return requirements.PassAs<base::Value>();
758 } 494 }
759 495
496 bool TileManager::FreeTileResourcesUntilUsageIsWithinLimit(
497 EvictionTileIterator* iterator,
498 const MemoryUsage& limit,
499 MemoryUsage* usage) {
500 while (usage->Exceeds(limit)) {
501 if (!*iterator)
502 return false;
503
504 Tile* tile = **iterator;
505 *usage -= MemoryUsage::FromTile(tile);
506
507 FreeResourcesForTileAndNotifyClientIfTileWasReadyToDraw(tile);
508 ++(*iterator);
509 }
510 return true;
511 }
512
513 bool TileManager::FreeTileResourcesWithLowerPriorityUntilUsageIsWithinLimit(
514 EvictionTileIterator* iterator,
515 const MemoryUsage& limit,
516 const TilePriority& max_priority,
reveman 2014/06/18 03:35:42 other_priority
vmpstr 2014/06/18 06:45:00 Done.
517 MemoryUsage* usage) {
518 while (usage->Exceeds(limit)) {
519 if (!*iterator)
520 return false;
521
522 Tile* tile = **iterator;
523 if (!max_priority.IsHigherPriorityThan(
524 tile->priority_for_tree_priority(global_state_.tree_priority))) {
525 return false;
526 }
527
528 *usage -= MemoryUsage::FromTile(tile);
reveman 2014/06/18 03:35:42 nit: please use blank lines consistently. why grou
vmpstr 2014/06/18 06:45:01 Done.
529 FreeResourcesForTileAndNotifyClientIfTileWasReadyToDraw(tile);
530 ++(*iterator);
531 }
532 return true;
533 }
534
535 bool TileManager::TilePriorityViolatesMemoryPolicy(
536 const TilePriority& priority) {
537 switch (global_state_.memory_limit_policy) {
538 case ALLOW_NOTHING:
539 return true;
540 case ALLOW_ABSOLUTE_MINIMUM:
541 return priority.priority_bin > TilePriority::NOW;
542 case ALLOW_PREPAINT_ONLY:
543 return priority.priority_bin > TilePriority::SOON;
544 case ALLOW_ANYTHING:
545 return priority.distance_to_visible ==
546 std::numeric_limits<float>::infinity();
547 }
548 NOTREACHED();
549 return true;
550 }
551
760 void TileManager::AssignGpuMemoryToTiles( 552 void TileManager::AssignGpuMemoryToTiles(
761 PrioritizedTileSet* tiles,
762 TileVector* tiles_that_need_to_be_rasterized) { 553 TileVector* tiles_that_need_to_be_rasterized) {
763 TRACE_EVENT0("cc", "TileManager::AssignGpuMemoryToTiles"); 554 TRACE_EVENT0("cc", "TileManager::AssignGpuMemoryToTiles");
764 555
765 // Maintain the list of released resources that can potentially be re-used 556 // Maintain the list of released resources that can potentially be re-used
766 // or deleted. 557 // or deleted.
767 // If this operation becomes expensive too, only do this after some 558 // If this operation becomes expensive too, only do this after some
768 // resource(s) was returned. Note that in that case, one also need to 559 // resource(s) was returned. Note that in that case, one also need to
769 // invalidate when releasing some resource from the pool. 560 // invalidate when releasing some resource from the pool.
770 resource_pool_->CheckBusyResources(); 561 resource_pool_->CheckBusyResources();
771 562
772 // Now give memory out to the tiles until we're out, and build 563 // Now give memory out to the tiles until we're out, and build
773 // the needs-to-be-rasterized queue. 564 // the needs-to-be-rasterized queue.
774 all_tiles_that_need_to_be_rasterized_have_memory_ = true; 565 all_tiles_that_need_to_be_rasterized_have_memory_ = true;
775 all_tiles_required_for_activation_have_memory_ = true;
776 566
777 // Cast to prevent overflow. 567 MemoryUsage hard_memory_limit(global_state_.hard_memory_limit_in_bytes,
778 int64 soft_bytes_available = 568 global_state_.num_resources_limit);
779 static_cast<int64>(bytes_releasable_) + 569 MemoryUsage soft_memory_limit(global_state_.soft_memory_limit_in_bytes,
780 static_cast<int64>(global_state_.soft_memory_limit_in_bytes) - 570 global_state_.num_resources_limit);
781 static_cast<int64>(resource_pool_->acquired_memory_usage_bytes()); 571 MemoryUsage memory_usage(resource_pool_->acquired_memory_usage_bytes(),
782 int64 hard_bytes_available = 572 resource_pool_->acquired_resource_count());
783 static_cast<int64>(bytes_releasable_) +
784 static_cast<int64>(global_state_.hard_memory_limit_in_bytes) -
785 static_cast<int64>(resource_pool_->acquired_memory_usage_bytes());
786 int resources_available = resources_releasable_ +
787 global_state_.num_resources_limit -
788 resource_pool_->acquired_resource_count();
789 size_t soft_bytes_allocatable =
790 std::max(static_cast<int64>(0), soft_bytes_available);
791 size_t hard_bytes_allocatable =
792 std::max(static_cast<int64>(0), hard_bytes_available);
793 size_t resources_allocatable = std::max(0, resources_available);
794 573
795 size_t bytes_that_exceeded_memory_budget = 0; 574 EvictionTileIterator eviction_it(this, global_state_.tree_priority);
796 size_t soft_bytes_left = soft_bytes_allocatable;
797 size_t hard_bytes_left = hard_bytes_allocatable;
798 575
799 size_t resources_left = resources_allocatable; 576 FreeTileResourcesUntilUsageIsWithinLimit(
577 &eviction_it, hard_memory_limit, &memory_usage);
reveman 2014/06/18 03:35:42 Why this call here rather than after the loop? Mak
vmpstr 2014/06/18 06:45:00 I think this has to happen before. Check out the l
reveman 2014/06/18 16:41:09 Ah, I think I understand. See my comments on lates
578
800 bool oomed_soft = false; 579 bool oomed_soft = false;
reveman 2014/06/18 03:35:42 I don't think you need this anymore. You break out
vmpstr 2014/06/18 06:45:00 Done.
801 bool oomed_hard = false; 580 bool oomed_hard = false;
802 bool have_hit_soft_memory = false; // Soft memory comes after hard.
803 581
804 unsigned schedule_priority = 1u; 582 unsigned schedule_priority = 1u;
805 for (PrioritizedTileSet::Iterator it(tiles, true); it; ++it) { 583 for (RasterTileIterator it(this, global_state_.tree_priority); it; ++it) {
806 Tile* tile = *it; 584 Tile* tile = *it;
585 TilePriority priority =
586 tile->priority_for_tree_priority(global_state_.tree_priority);
587
588 if (TilePriorityViolatesMemoryPolicy(priority))
589 break;
590
807 ManagedTileState& mts = tile->managed_state(); 591 ManagedTileState& mts = tile->managed_state();
808
809 mts.scheduled_priority = schedule_priority++; 592 mts.scheduled_priority = schedule_priority++;
810
811 mts.raster_mode = tile->DetermineOverallRasterMode(); 593 mts.raster_mode = tile->DetermineOverallRasterMode();
812
813 ManagedTileState::TileVersion& tile_version = 594 ManagedTileState::TileVersion& tile_version =
814 mts.tile_versions[mts.raster_mode]; 595 mts.tile_versions[mts.raster_mode];
815 596
816 // If this tile doesn't need a resource, then nothing to do. 597 DCHECK(!tile_version.IsReadyToDraw());
817 if (!tile_version.requires_resource())
818 continue;
819 598
820 // If the tile is not needed, free it up. 599 // If the tile version is not in flight, then we'll have to pay to create a
821 if (mts.bin == NEVER_BIN) { 600 // new task. Additionally, we might have to evict some tiles for this to
822 FreeResourcesForTileAndNotifyClientIfTileWasReadyToDraw(tile); 601 // happen.
823 continue; 602 if (!tile_version.raster_task_) {
824 } 603 MemoryUsage additional_memory_required = MemoryUsage::FromConfig(
604 tile->size(), resource_pool_->resource_format());
825 605
826 const bool tile_uses_hard_limit = mts.bin <= NOW_BIN; 606 bool tile_uses_hard_limit = priority.priority_bin == TilePriority::NOW;
827 const size_t bytes_if_allocated = BytesConsumedIfAllocated(tile); 607 MemoryUsage& memory_limit =
828 const size_t tile_bytes_left = 608 tile_uses_hard_limit ? hard_memory_limit : soft_memory_limit;
829 (tile_uses_hard_limit) ? hard_bytes_left : soft_bytes_left;
830 609
831 // Hard-limit is reserved for tiles that would cause a calamity 610 bool memory_reduced_successfully =
832 // if they were to go away, so by definition they are the highest 611 FreeTileResourcesWithLowerPriorityUntilUsageIsWithinLimit(
833 // priority memory, and must be at the front of the list. 612 &eviction_it,
834 DCHECK(!(have_hit_soft_memory && tile_uses_hard_limit)); 613 memory_limit - additional_memory_required,
835 have_hit_soft_memory |= !tile_uses_hard_limit; 614 priority,
836 615 &memory_usage);
837 size_t tile_bytes = 0; 616 if (memory_reduced_successfully) {
838 size_t tile_resources = 0; 617 memory_usage += additional_memory_required;
reveman 2014/06/18 03:35:42 hm, this might adjust memory_usage even if the til
vmpstr 2014/06/18 06:45:01 Done.
839 618 } else {
840 // It costs to maintain a resource. 619 oomed_soft = true;
841 for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) { 620 if (tile_uses_hard_limit)
842 if (mts.tile_versions[mode].resource_) { 621 oomed_hard = true;
843 tile_bytes += bytes_if_allocated;
844 tile_resources++;
845 } 622 }
846 } 623 }
847 624
848 // Allow lower priority tiles with initialized resources to keep
849 // their memory by only assigning memory to new raster tasks if
850 // they can be scheduled.
851 bool reached_scheduled_raster_tasks_limit =
852 tiles_that_need_to_be_rasterized->size() >= kScheduledRasterTasksLimit;
853 if (!reached_scheduled_raster_tasks_limit) {
854 // If we don't have the required version, and it's not in flight
855 // then we'll have to pay to create a new task.
856 if (!tile_version.resource_ && !tile_version.raster_task_) {
857 tile_bytes += bytes_if_allocated;
858 tile_resources++;
859 }
860 }
861
862 // Tile is OOM.
863 if (tile_bytes > tile_bytes_left || tile_resources > resources_left) {
864 bool was_ready_to_draw = tile->IsReadyToDraw();
865
866 FreeResourcesForTile(tile);
867
868 // This tile was already on screen and now its resources have been
869 // released. In order to prevent checkerboarding, set this tile as
870 // rasterize on demand immediately.
871 if (mts.visible_and_ready_to_draw)
872 tile_version.set_rasterize_on_demand();
873
874 if (was_ready_to_draw)
875 client_->NotifyTileStateChanged(tile);
876
877 oomed_soft = true;
878 if (tile_uses_hard_limit) {
879 oomed_hard = true;
880 bytes_that_exceeded_memory_budget += tile_bytes;
881 }
882 } else {
883 resources_left -= tile_resources;
884 hard_bytes_left -= tile_bytes;
885 soft_bytes_left =
886 (soft_bytes_left > tile_bytes) ? soft_bytes_left - tile_bytes : 0;
887 if (tile_version.resource_)
888 continue;
889 }
890
891 DCHECK(!tile_version.resource_);
892
893 // Tile shouldn't be rasterized if |tiles_that_need_to_be_rasterized| 625 // Tile shouldn't be rasterized if |tiles_that_need_to_be_rasterized|
894 // has reached it's limit or we've failed to assign gpu memory to this 626 // has reached it's limit or we've failed to assign gpu memory to this
895 // or any higher priority tile. Preventing tiles that fit into memory 627 // or any higher priority tile. Preventing tiles that fit into memory
896 // budget to be rasterized when higher priority tile is oom is 628 // budget to be rasterized when higher priority tile is oom is
897 // important for two reasons: 629 // important for two reasons:
898 // 1. Tile size should not impact raster priority. 630 // 1. Tile size should not impact raster priority.
899 // 2. Tiles with existing raster task could otherwise incorrectly 631 // 2. Tiles with existing raster task could otherwise incorrectly
900 // be added as they are not affected by |bytes_allocatable|. 632 // be added as they are not affected by |bytes_allocatable|.
reveman 2014/06/18 03:35:42 I don't think this comment apply anymore now that
vmpstr 2014/06/18 06:45:00 Done.
901 bool can_schedule_tile = 633 bool can_schedule_tile =
902 !oomed_soft && !reached_scheduled_raster_tasks_limit; 634 !oomed_soft &&
635 tiles_that_need_to_be_rasterized->size() < kScheduledRasterTasksLimit;
reveman 2014/06/18 03:35:42 I wonder if some of this can be moved up to make t
vmpstr 2014/06/18 06:45:00 Done (more or less?). I think it kind of naturally
903 636
904 if (!can_schedule_tile) { 637 if (!can_schedule_tile) {
905 all_tiles_that_need_to_be_rasterized_have_memory_ = false; 638 all_tiles_that_need_to_be_rasterized_have_memory_ = false;
906 if (tile->required_for_activation()) 639 break;
907 all_tiles_required_for_activation_have_memory_ = false;
908 it.DisablePriorityOrdering();
909 continue;
910 } 640 }
911 641
912 tiles_that_need_to_be_rasterized->push_back(tile); 642 tiles_that_need_to_be_rasterized->push_back(tile);
913 } 643 }
914 644
915 // OOM reporting uses hard-limit, soft-OOM is normal depending on limit. 645 // OOM reporting uses hard-limit, soft-OOM is normal depending on limit.
916 ever_exceeded_memory_budget_ |= oomed_hard; 646 ever_exceeded_memory_budget_ |= oomed_hard;
917 if (ever_exceeded_memory_budget_) { 647 if (ever_exceeded_memory_budget_) {
918 TRACE_COUNTER_ID2("cc", 648 TRACE_COUNTER_ID1("cc",
919 "over_memory_budget", 649 "over_memory_budget",
920 this, 650 this,
921 "budget", 651 global_state_.hard_memory_limit_in_bytes);
reveman 2014/06/18 03:35:42 does this counter still make sense? how is showing
vmpstr 2014/06/18 06:45:01 Removed.
922 global_state_.hard_memory_limit_in_bytes,
923 "over",
924 bytes_that_exceeded_memory_budget);
925 } 652 }
926 memory_stats_from_last_assign_.total_budget_in_bytes = 653 memory_stats_from_last_assign_.total_budget_in_bytes =
927 global_state_.hard_memory_limit_in_bytes; 654 global_state_.hard_memory_limit_in_bytes;
928 memory_stats_from_last_assign_.bytes_allocated = 655 memory_stats_from_last_assign_.bytes_allocated =
929 hard_bytes_allocatable - hard_bytes_left; 656 resource_pool_->acquired_memory_usage_bytes();
930 memory_stats_from_last_assign_.bytes_unreleasable = 657 memory_stats_from_last_assign_.bytes_unreleasable =
931 resource_pool_->acquired_memory_usage_bytes() - bytes_releasable_; 658 memory_usage.memory_bytes() -
932 memory_stats_from_last_assign_.bytes_over = bytes_that_exceeded_memory_budget; 659 resource_pool_->acquired_memory_usage_bytes();
reveman 2014/06/18 03:35:42 not sure this is completely true (as it doesn't in
vmpstr 2014/06/18 06:45:00 Yeah, I agree. However, I would prefer to keep it
reveman 2014/06/18 16:41:09 I don't think it will be correct. memory_usage and
660 memory_stats_from_last_assign_.had_enough_memory = !oomed_hard;
933 } 661 }
934 662
935 void TileManager::FreeResourceForTile(Tile* tile, RasterMode mode) { 663 void TileManager::FreeResourceForTile(Tile* tile, RasterMode mode) {
936 ManagedTileState& mts = tile->managed_state(); 664 ManagedTileState& mts = tile->managed_state();
937 if (mts.tile_versions[mode].resource_) { 665 if (mts.tile_versions[mode].resource_)
938 resource_pool_->ReleaseResource(mts.tile_versions[mode].resource_.Pass()); 666 resource_pool_->ReleaseResource(mts.tile_versions[mode].resource_.Pass());
939
940 DCHECK_GE(bytes_releasable_, BytesConsumedIfAllocated(tile));
941 DCHECK_GE(resources_releasable_, 1u);
942
943 bytes_releasable_ -= BytesConsumedIfAllocated(tile);
944 --resources_releasable_;
945 }
946 } 667 }
947 668
948 void TileManager::FreeResourcesForTile(Tile* tile) { 669 void TileManager::FreeResourcesForTile(Tile* tile) {
949 for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) { 670 for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) {
950 FreeResourceForTile(tile, static_cast<RasterMode>(mode)); 671 FreeResourceForTile(tile, static_cast<RasterMode>(mode));
951 } 672 }
952 } 673 }
953 674
954 void TileManager::FreeUnusedResourcesForTile(Tile* tile) { 675 void TileManager::FreeUnusedResourcesForTile(Tile* tile) {
955 DCHECK(tile->IsReadyToDraw()); 676 DCHECK(tile->IsReadyToDraw());
(...skipping 181 matching lines...) Expand 10 before | Expand all | Expand 10 after
1137 } 858 }
1138 859
1139 ++update_visible_tiles_stats_.completed_count; 860 ++update_visible_tiles_stats_.completed_count;
1140 861
1141 if (analysis.is_solid_color) { 862 if (analysis.is_solid_color) {
1142 tile_version.set_solid_color(analysis.solid_color); 863 tile_version.set_solid_color(analysis.solid_color);
1143 resource_pool_->ReleaseResource(resource.Pass()); 864 resource_pool_->ReleaseResource(resource.Pass());
1144 } else { 865 } else {
1145 tile_version.set_use_resource(); 866 tile_version.set_use_resource();
1146 tile_version.resource_ = resource.Pass(); 867 tile_version.resource_ = resource.Pass();
1147
1148 bytes_releasable_ += BytesConsumedIfAllocated(tile);
1149 ++resources_releasable_;
1150 } 868 }
1151 869
1152 FreeUnusedResourcesForTile(tile); 870 FreeUnusedResourcesForTile(tile);
1153 if (tile->priority(ACTIVE_TREE).distance_to_visible == 0.f) 871 if (tile->priority(ACTIVE_TREE).distance_to_visible == 0.f)
1154 did_initialize_visible_tile_ = true; 872 did_initialize_visible_tile_ = true;
1155 873
1156 client_->NotifyTileStateChanged(tile); 874 client_->NotifyTileStateChanged(tile);
1157 } 875 }
1158 876
1159 scoped_refptr<Tile> TileManager::CreateTile(PicturePileImpl* picture_pile, 877 scoped_refptr<Tile> TileManager::CreateTile(PicturePileImpl* picture_pile,
(...skipping 10 matching lines...) Expand all
1170 content_rect, 888 content_rect,
1171 opaque_rect, 889 opaque_rect,
1172 contents_scale, 890 contents_scale,
1173 layer_id, 891 layer_id,
1174 source_frame_number, 892 source_frame_number,
1175 flags)); 893 flags));
1176 DCHECK(tiles_.find(tile->id()) == tiles_.end()); 894 DCHECK(tiles_.find(tile->id()) == tiles_.end());
1177 895
1178 tiles_[tile->id()] = tile; 896 tiles_[tile->id()] = tile;
1179 used_layer_counts_[tile->layer_id()]++; 897 used_layer_counts_[tile->layer_id()]++;
1180 prioritized_tiles_dirty_ = true;
1181 return tile; 898 return tile;
1182 } 899 }
1183 900
1184 void TileManager::GetPairedPictureLayers( 901 void TileManager::GetPairedPictureLayers(
1185 std::vector<PairedPictureLayer>* paired_layers) const { 902 std::vector<PairedPictureLayer>* paired_layers) const {
1186 const std::vector<PictureLayerImpl*>& layers = client_->GetPictureLayers(); 903 const std::vector<PictureLayerImpl*>& layers = client_->GetPictureLayers();
1187 904
1188 paired_layers->clear(); 905 paired_layers->clear();
1189 // Reserve a maximum possible paired layers. 906 // Reserve a maximum possible paired layers.
1190 paired_layers->reserve(layers.size()); 907 paired_layers->reserve(layers.size());
(...skipping 432 matching lines...) Expand 10 before | Expand all | Expand 10 after
1623 void TileManager::CheckIfReadyToActivate() { 1340 void TileManager::CheckIfReadyToActivate() {
1624 TRACE_EVENT0("cc", "TileManager::CheckIfReadyToActivate"); 1341 TRACE_EVENT0("cc", "TileManager::CheckIfReadyToActivate");
1625 1342
1626 rasterizer_->CheckForCompletedTasks(); 1343 rasterizer_->CheckForCompletedTasks();
1627 did_check_for_completed_tasks_since_last_schedule_tasks_ = true; 1344 did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
1628 1345
1629 if (IsReadyToActivate()) 1346 if (IsReadyToActivate())
1630 client_->NotifyReadyToActivate(); 1347 client_->NotifyReadyToActivate();
1631 } 1348 }
1632 1349
1350 TileManager::MemoryUsage::MemoryUsage() : memory_bytes_(0), resource_count_(0) {
1351 }
1352
1353 TileManager::MemoryUsage::MemoryUsage(int64 memory_bytes, int resource_count)
1354 : memory_bytes_(memory_bytes), resource_count_(resource_count) {
1355 }
1356
1357 // static
1358 TileManager::MemoryUsage TileManager::MemoryUsage::FromConfig(
1359 const gfx::Size& size,
1360 ResourceFormat format) {
1361 return MemoryUsage(Resource::MemorySizeBytes(size, format), 1);
1362 }
1363
1364 // static
1365 TileManager::MemoryUsage TileManager::MemoryUsage::FromTile(const Tile* tile) {
1366 const ManagedTileState& mts = tile->managed_state();
1367 MemoryUsage total_usage;
1368 for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) {
1369 if (mts.tile_versions[mode].resource_) {
1370 total_usage += MemoryUsage::FromConfig(
1371 tile->size(), mts.tile_versions[mode].resource_->format());
1372 }
1373 }
1374 return total_usage;
1375 }
1376
1377 TileManager::MemoryUsage& TileManager::MemoryUsage::operator+=(
1378 const MemoryUsage& other) {
1379 memory_bytes_ += other.memory_bytes_;
1380 resource_count_ += other.resource_count_;
1381 return *this;
1382 }
1383
1384 TileManager::MemoryUsage& TileManager::MemoryUsage::operator-=(
1385 const MemoryUsage& other) {
1386 memory_bytes_ -= other.memory_bytes_;
1387 resource_count_ -= other.resource_count_;
1388 return *this;
1389 }
1390
1391 TileManager::MemoryUsage TileManager::MemoryUsage::operator-(
1392 const MemoryUsage& other) {
1393 MemoryUsage result = *this;
1394 result -= other;
1395 return result;
1396 }
1397
1398 bool TileManager::MemoryUsage::Exceeds(const MemoryUsage& limit) const {
1399 return memory_bytes_ > limit.memory_bytes_ ||
1400 resource_count_ > limit.resource_count_;
1401 }
1402
1633 } // namespace cc 1403 } // namespace cc
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698