OLD | NEW |
---|---|
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 227 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
238 skia::RefPtr<SkPixelRef> pixel_ref_; | 238 skia::RefPtr<SkPixelRef> pixel_ref_; |
239 int layer_id_; | 239 int layer_id_; |
240 RenderingStatsInstrumentation* rendering_stats_; | 240 RenderingStatsInstrumentation* rendering_stats_; |
241 const base::Callback<void(bool was_canceled)> reply_; | 241 const base::Callback<void(bool was_canceled)> reply_; |
242 | 242 |
243 DISALLOW_COPY_AND_ASSIGN(ImageDecodeTaskImpl); | 243 DISALLOW_COPY_AND_ASSIGN(ImageDecodeTaskImpl); |
244 }; | 244 }; |
245 | 245 |
246 const size_t kScheduledRasterTasksLimit = 32u; | 246 const size_t kScheduledRasterTasksLimit = 32u; |
247 | 247 |
248 // Memory limit policy works by mapping some bin states to the NEVER bin. | |
249 const ManagedTileBin kBinPolicyMap[NUM_TILE_MEMORY_LIMIT_POLICIES][NUM_BINS] = { | |
250 // [ALLOW_NOTHING] | |
251 {NEVER_BIN, // [NOW_AND_READY_TO_DRAW_BIN] | |
252 NEVER_BIN, // [NOW_BIN] | |
253 NEVER_BIN, // [SOON_BIN] | |
254 NEVER_BIN, // [EVENTUALLY_AND_ACTIVE_BIN] | |
255 NEVER_BIN, // [EVENTUALLY_BIN] | |
256 NEVER_BIN, // [AT_LAST_AND_ACTIVE_BIN] | |
257 NEVER_BIN, // [AT_LAST_BIN] | |
258 NEVER_BIN // [NEVER_BIN] | |
259 }, | |
260 // [ALLOW_ABSOLUTE_MINIMUM] | |
261 {NOW_AND_READY_TO_DRAW_BIN, // [NOW_AND_READY_TO_DRAW_BIN] | |
262 NOW_BIN, // [NOW_BIN] | |
263 NEVER_BIN, // [SOON_BIN] | |
264 NEVER_BIN, // [EVENTUALLY_AND_ACTIVE_BIN] | |
265 NEVER_BIN, // [EVENTUALLY_BIN] | |
266 NEVER_BIN, // [AT_LAST_AND_ACTIVE_BIN] | |
267 NEVER_BIN, // [AT_LAST_BIN] | |
268 NEVER_BIN // [NEVER_BIN] | |
269 }, | |
270 // [ALLOW_PREPAINT_ONLY] | |
271 {NOW_AND_READY_TO_DRAW_BIN, // [NOW_AND_READY_TO_DRAW_BIN] | |
272 NOW_BIN, // [NOW_BIN] | |
273 SOON_BIN, // [SOON_BIN] | |
274 NEVER_BIN, // [EVENTUALLY_AND_ACTIVE_BIN] | |
275 NEVER_BIN, // [EVENTUALLY_BIN] | |
276 NEVER_BIN, // [AT_LAST_AND_ACTIVE_BIN] | |
277 NEVER_BIN, // [AT_LAST_BIN] | |
278 NEVER_BIN // [NEVER_BIN] | |
279 }, | |
280 // [ALLOW_ANYTHING] | |
281 {NOW_AND_READY_TO_DRAW_BIN, // [NOW_AND_READY_TO_DRAW_BIN] | |
282 NOW_BIN, // [NOW_BIN] | |
283 SOON_BIN, // [SOON_BIN] | |
284 EVENTUALLY_AND_ACTIVE_BIN, // [EVENTUALLY_AND_ACTIVE_BIN] | |
285 EVENTUALLY_BIN, // [EVENTUALLY_BIN] | |
286 AT_LAST_AND_ACTIVE_BIN, // [AT_LAST_AND_ACTIVE_BIN] | |
287 AT_LAST_BIN, // [AT_LAST_BIN] | |
288 NEVER_BIN // [NEVER_BIN] | |
289 }}; | |
290 | |
291 // Ready to draw works by mapping NOW_BIN to NOW_AND_READY_TO_DRAW_BIN. | |
292 const ManagedTileBin kBinReadyToDrawMap[2][NUM_BINS] = { | |
293 // Not ready | |
294 {NOW_AND_READY_TO_DRAW_BIN, // [NOW_AND_READY_TO_DRAW_BIN] | |
295 NOW_BIN, // [NOW_BIN] | |
296 SOON_BIN, // [SOON_BIN] | |
297 EVENTUALLY_AND_ACTIVE_BIN, // [EVENTUALLY_AND_ACTIVE_BIN] | |
298 EVENTUALLY_BIN, // [EVENTUALLY_BIN] | |
299 AT_LAST_AND_ACTIVE_BIN, // [AT_LAST_AND_ACTIVE_BIN] | |
300 AT_LAST_BIN, // [AT_LAST_BIN] | |
301 NEVER_BIN // [NEVER_BIN] | |
302 }, | |
303 // Ready | |
304 {NOW_AND_READY_TO_DRAW_BIN, // [NOW_AND_READY_TO_DRAW_BIN] | |
305 NOW_AND_READY_TO_DRAW_BIN, // [NOW_BIN] | |
306 SOON_BIN, // [SOON_BIN] | |
307 EVENTUALLY_AND_ACTIVE_BIN, // [EVENTUALLY_AND_ACTIVE_BIN] | |
308 EVENTUALLY_BIN, // [EVENTUALLY_BIN] | |
309 AT_LAST_AND_ACTIVE_BIN, // [AT_LAST_AND_ACTIVE_BIN] | |
310 AT_LAST_BIN, // [AT_LAST_BIN] | |
311 NEVER_BIN // [NEVER_BIN] | |
312 }}; | |
313 | |
314 // Active works by mapping some bin stats to equivalent _ACTIVE_BIN state. | |
315 const ManagedTileBin kBinIsActiveMap[2][NUM_BINS] = { | |
316 // Inactive | |
317 {NOW_AND_READY_TO_DRAW_BIN, // [NOW_AND_READY_TO_DRAW_BIN] | |
318 NOW_BIN, // [NOW_BIN] | |
319 SOON_BIN, // [SOON_BIN] | |
320 EVENTUALLY_AND_ACTIVE_BIN, // [EVENTUALLY_AND_ACTIVE_BIN] | |
321 EVENTUALLY_BIN, // [EVENTUALLY_BIN] | |
322 AT_LAST_AND_ACTIVE_BIN, // [AT_LAST_AND_ACTIVE_BIN] | |
323 AT_LAST_BIN, // [AT_LAST_BIN] | |
324 NEVER_BIN // [NEVER_BIN] | |
325 }, | |
326 // Active | |
327 {NOW_AND_READY_TO_DRAW_BIN, // [NOW_AND_READY_TO_DRAW_BIN] | |
328 NOW_BIN, // [NOW_BIN] | |
329 SOON_BIN, // [SOON_BIN] | |
330 EVENTUALLY_AND_ACTIVE_BIN, // [EVENTUALLY_AND_ACTIVE_BIN] | |
331 EVENTUALLY_AND_ACTIVE_BIN, // [EVENTUALLY_BIN] | |
332 AT_LAST_AND_ACTIVE_BIN, // [AT_LAST_AND_ACTIVE_BIN] | |
333 AT_LAST_AND_ACTIVE_BIN, // [AT_LAST_BIN] | |
334 NEVER_BIN // [NEVER_BIN] | |
335 }}; | |
336 | |
337 // Determine bin based on three categories of tiles: things we need now, | |
338 // things we need soon, and eventually. | |
339 inline ManagedTileBin BinFromTilePriority(const TilePriority& prio) { | |
340 if (prio.priority_bin == TilePriority::NOW) | |
341 return NOW_BIN; | |
342 | |
343 if (prio.priority_bin == TilePriority::SOON) | |
344 return SOON_BIN; | |
345 | |
346 if (prio.distance_to_visible == std::numeric_limits<float>::infinity()) | |
347 return NEVER_BIN; | |
348 | |
349 return EVENTUALLY_BIN; | |
350 } | |
351 | |
352 } // namespace | 248 } // namespace |
353 | 249 |
354 RasterTaskCompletionStats::RasterTaskCompletionStats() | 250 RasterTaskCompletionStats::RasterTaskCompletionStats() |
355 : completed_count(0u), canceled_count(0u) {} | 251 : completed_count(0u), canceled_count(0u) {} |
356 | 252 |
357 scoped_ptr<base::Value> RasterTaskCompletionStatsAsValue( | 253 scoped_ptr<base::Value> RasterTaskCompletionStatsAsValue( |
358 const RasterTaskCompletionStats& stats) { | 254 const RasterTaskCompletionStats& stats) { |
359 scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue()); | 255 scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue()); |
360 state->SetInteger("completed_count", stats.completed_count); | 256 state->SetInteger("completed_count", stats.completed_count); |
361 state->SetInteger("canceled_count", stats.canceled_count); | 257 state->SetInteger("canceled_count", stats.canceled_count); |
(...skipping 16 matching lines...) Expand all Loading... | |
378 | 274 |
379 TileManager::TileManager( | 275 TileManager::TileManager( |
380 TileManagerClient* client, | 276 TileManagerClient* client, |
381 ResourcePool* resource_pool, | 277 ResourcePool* resource_pool, |
382 Rasterizer* rasterizer, | 278 Rasterizer* rasterizer, |
383 bool use_rasterize_on_demand, | 279 bool use_rasterize_on_demand, |
384 RenderingStatsInstrumentation* rendering_stats_instrumentation) | 280 RenderingStatsInstrumentation* rendering_stats_instrumentation) |
385 : client_(client), | 281 : client_(client), |
386 resource_pool_(resource_pool), | 282 resource_pool_(resource_pool), |
387 rasterizer_(rasterizer), | 283 rasterizer_(rasterizer), |
388 prioritized_tiles_dirty_(false), | |
389 all_tiles_that_need_to_be_rasterized_have_memory_(true), | 284 all_tiles_that_need_to_be_rasterized_have_memory_(true), |
390 all_tiles_required_for_activation_have_memory_(true), | 285 all_tiles_required_for_activation_have_memory_(true), |
391 memory_required_bytes_(0), | |
392 memory_nice_to_have_bytes_(0), | |
393 bytes_releasable_(0), | 286 bytes_releasable_(0), |
394 resources_releasable_(0), | 287 resources_releasable_(0), |
395 ever_exceeded_memory_budget_(false), | 288 ever_exceeded_memory_budget_(false), |
396 rendering_stats_instrumentation_(rendering_stats_instrumentation), | 289 rendering_stats_instrumentation_(rendering_stats_instrumentation), |
397 did_initialize_visible_tile_(false), | 290 did_initialize_visible_tile_(false), |
398 did_check_for_completed_tasks_since_last_schedule_tasks_(true), | 291 did_check_for_completed_tasks_since_last_schedule_tasks_(true), |
399 use_rasterize_on_demand_(use_rasterize_on_demand) { | 292 use_rasterize_on_demand_(use_rasterize_on_demand) { |
400 rasterizer_->SetClient(this); | 293 rasterizer_->SetClient(this); |
401 } | 294 } |
402 | 295 |
(...skipping 19 matching lines...) Expand all Loading... | |
422 | 315 |
423 for (std::vector<PictureLayerImpl*>::iterator it = layers_.begin(); | 316 for (std::vector<PictureLayerImpl*>::iterator it = layers_.begin(); |
424 it != layers_.end(); | 317 it != layers_.end(); |
425 ++it) { | 318 ++it) { |
426 (*it)->DidUnregisterLayer(); | 319 (*it)->DidUnregisterLayer(); |
427 } | 320 } |
428 layers_.clear(); | 321 layers_.clear(); |
429 } | 322 } |
430 | 323 |
431 void TileManager::Release(Tile* tile) { | 324 void TileManager::Release(Tile* tile) { |
432 prioritized_tiles_dirty_ = true; | |
433 released_tiles_.push_back(tile); | 325 released_tiles_.push_back(tile); |
434 } | 326 } |
435 | 327 |
436 void TileManager::DidChangeTilePriority(Tile* tile) { | |
437 prioritized_tiles_dirty_ = true; | |
438 } | |
439 | |
440 bool TileManager::ShouldForceTasksRequiredForActivationToComplete() const { | 328 bool TileManager::ShouldForceTasksRequiredForActivationToComplete() const { |
441 return global_state_.tree_priority != SMOOTHNESS_TAKES_PRIORITY; | 329 return global_state_.tree_priority != SMOOTHNESS_TAKES_PRIORITY; |
442 } | 330 } |
443 | 331 |
444 void TileManager::CleanUpReleasedTiles() { | 332 void TileManager::CleanUpReleasedTiles() { |
445 for (std::vector<Tile*>::iterator it = released_tiles_.begin(); | 333 for (std::vector<Tile*>::iterator it = released_tiles_.begin(); |
446 it != released_tiles_.end(); | 334 it != released_tiles_.end(); |
447 ++it) { | 335 ++it) { |
448 Tile* tile = *it; | 336 Tile* tile = *it; |
449 ManagedTileState& mts = tile->managed_state(); | 337 ManagedTileState& mts = tile->managed_state(); |
(...skipping 13 matching lines...) Expand all Loading... | |
463 used_layer_counts_.erase(layer_it); | 351 used_layer_counts_.erase(layer_it); |
464 image_decode_tasks_.erase(tile->layer_id()); | 352 image_decode_tasks_.erase(tile->layer_id()); |
465 } | 353 } |
466 | 354 |
467 delete tile; | 355 delete tile; |
468 } | 356 } |
469 | 357 |
470 released_tiles_.clear(); | 358 released_tiles_.clear(); |
471 } | 359 } |
472 | 360 |
473 void TileManager::UpdatePrioritizedTileSetIfNeeded() { | |
474 if (!prioritized_tiles_dirty_) | |
475 return; | |
476 | |
477 CleanUpReleasedTiles(); | |
478 | |
479 prioritized_tiles_.Clear(); | |
480 GetTilesWithAssignedBins(&prioritized_tiles_); | |
481 prioritized_tiles_dirty_ = false; | |
482 } | |
483 | |
484 void TileManager::DidFinishRunningTasks() { | 361 void TileManager::DidFinishRunningTasks() { |
485 TRACE_EVENT0("cc", "TileManager::DidFinishRunningTasks"); | 362 TRACE_EVENT0("cc", "TileManager::DidFinishRunningTasks"); |
486 | 363 |
487 bool memory_usage_above_limit = resource_pool_->total_memory_usage_bytes() > | 364 bool memory_usage_above_limit = resource_pool_->total_memory_usage_bytes() > |
488 global_state_.soft_memory_limit_in_bytes; | 365 global_state_.soft_memory_limit_in_bytes; |
489 | 366 |
490 // When OOM, keep re-assigning memory until we reach a steady state | 367 // When OOM, keep re-assigning memory until we reach a steady state |
491 // where top-priority tiles are initialized. | 368 // where top-priority tiles are initialized. |
492 if (all_tiles_that_need_to_be_rasterized_have_memory_ && | 369 if (all_tiles_that_need_to_be_rasterized_have_memory_ && |
493 !memory_usage_above_limit) | 370 !memory_usage_above_limit) |
494 return; | 371 return; |
495 | 372 |
496 rasterizer_->CheckForCompletedTasks(); | 373 rasterizer_->CheckForCompletedTasks(); |
497 did_check_for_completed_tasks_since_last_schedule_tasks_ = true; | 374 did_check_for_completed_tasks_since_last_schedule_tasks_ = true; |
498 | 375 |
499 TileVector tiles_that_need_to_be_rasterized; | 376 TileVector tiles_that_need_to_be_rasterized; |
500 AssignGpuMemoryToTiles(&prioritized_tiles_, | 377 AssignGpuMemoryToTiles(&tiles_that_need_to_be_rasterized); |
501 &tiles_that_need_to_be_rasterized); | |
502 | 378 |
503 // |tiles_that_need_to_be_rasterized| will be empty when we reach a | 379 // |tiles_that_need_to_be_rasterized| will be empty when we reach a |
504 // steady memory state. Keep scheduling tasks until we reach this state. | 380 // steady memory state. Keep scheduling tasks until we reach this state. |
505 if (!tiles_that_need_to_be_rasterized.empty()) { | 381 if (!tiles_that_need_to_be_rasterized.empty()) { |
506 ScheduleTasks(tiles_that_need_to_be_rasterized); | 382 ScheduleTasks(tiles_that_need_to_be_rasterized); |
507 return; | 383 return; |
508 } | 384 } |
509 | 385 |
510 resource_pool_->ReduceResourceUsage(); | 386 resource_pool_->ReduceResourceUsage(); |
511 | 387 |
(...skipping 29 matching lines...) Expand all Loading... | |
541 // activation are initialized when no tiles are OOM. We need to | 417 // activation are initialized when no tiles are OOM. We need to |
542 // wait for DidFinishRunningTasks() to be called, try to re-assign | 418 // wait for DidFinishRunningTasks() to be called, try to re-assign |
543 // memory and in worst case use on-demand raster when tiles | 419 // memory and in worst case use on-demand raster when tiles |
544 // required for activation are OOM. | 420 // required for activation are OOM. |
545 if (!all_tiles_required_for_activation_have_memory_) | 421 if (!all_tiles_required_for_activation_have_memory_) |
546 return; | 422 return; |
547 | 423 |
548 client_->NotifyReadyToActivate(); | 424 client_->NotifyReadyToActivate(); |
549 } | 425 } |
550 | 426 |
551 void TileManager::GetTilesWithAssignedBins(PrioritizedTileSet* tiles) { | |
552 TRACE_EVENT0("cc", "TileManager::GetTilesWithAssignedBins"); | |
553 | |
554 // Compute new stats to be return by GetMemoryStats(). | |
555 memory_required_bytes_ = 0; | |
556 memory_nice_to_have_bytes_ = 0; | |
557 | |
558 const TileMemoryLimitPolicy memory_policy = global_state_.memory_limit_policy; | |
559 const TreePriority tree_priority = global_state_.tree_priority; | |
560 | |
561 // For each tree, bin into different categories of tiles. | |
562 for (TileMap::const_iterator it = tiles_.begin(); it != tiles_.end(); ++it) { | |
563 Tile* tile = it->second; | |
564 ManagedTileState& mts = tile->managed_state(); | |
565 | |
566 const ManagedTileState::TileVersion& tile_version = | |
567 tile->GetTileVersionForDrawing(); | |
568 bool tile_is_ready_to_draw = tile_version.IsReadyToDraw(); | |
569 bool tile_is_active = tile_is_ready_to_draw || | |
570 mts.tile_versions[mts.raster_mode].raster_task_; | |
571 | |
572 // Get the active priority and bin. | |
573 TilePriority active_priority = tile->priority(ACTIVE_TREE); | |
574 ManagedTileBin active_bin = BinFromTilePriority(active_priority); | |
575 | |
576 // Get the pending priority and bin. | |
577 TilePriority pending_priority = tile->priority(PENDING_TREE); | |
578 ManagedTileBin pending_bin = BinFromTilePriority(pending_priority); | |
579 | |
580 bool pending_is_low_res = pending_priority.resolution == LOW_RESOLUTION; | |
581 bool pending_is_non_ideal = | |
582 pending_priority.resolution == NON_IDEAL_RESOLUTION; | |
583 bool active_is_non_ideal = | |
584 active_priority.resolution == NON_IDEAL_RESOLUTION; | |
585 | |
586 // Adjust bin state based on if ready to draw. | |
587 active_bin = kBinReadyToDrawMap[tile_is_ready_to_draw][active_bin]; | |
588 pending_bin = kBinReadyToDrawMap[tile_is_ready_to_draw][pending_bin]; | |
589 | |
590 // Adjust bin state based on if active. | |
591 active_bin = kBinIsActiveMap[tile_is_active][active_bin]; | |
592 pending_bin = kBinIsActiveMap[tile_is_active][pending_bin]; | |
593 | |
594 // We never want to paint new non-ideal tiles, as we always have | |
595 // a high-res tile covering that content (paint that instead). | |
596 if (!tile_is_ready_to_draw && active_is_non_ideal) | |
597 active_bin = NEVER_BIN; | |
598 if (!tile_is_ready_to_draw && pending_is_non_ideal) | |
599 pending_bin = NEVER_BIN; | |
600 | |
601 if (!tile_is_ready_to_draw || tile_version.requires_resource()) { | |
602 // The bin that the tile would have if the GPU memory manager had | |
603 // a maximally permissive policy, send to the GPU memory manager | |
604 // to determine policy. | |
605 ManagedTileBin gpu_memmgr_stats_bin = std::min(active_bin, pending_bin); | |
606 if ((gpu_memmgr_stats_bin == NOW_BIN) || | |
607 (gpu_memmgr_stats_bin == NOW_AND_READY_TO_DRAW_BIN)) | |
608 memory_required_bytes_ += BytesConsumedIfAllocated(tile); | |
609 if (gpu_memmgr_stats_bin != NEVER_BIN) | |
610 memory_nice_to_have_bytes_ += BytesConsumedIfAllocated(tile); | |
611 } | |
612 | |
613 ManagedTileBin tree_bin[NUM_TREES]; | |
614 tree_bin[ACTIVE_TREE] = kBinPolicyMap[memory_policy][active_bin]; | |
615 tree_bin[PENDING_TREE] = kBinPolicyMap[memory_policy][pending_bin]; | |
616 | |
617 // Adjust pending bin state for low res tiles. This prevents pending tree | |
618 // low-res tiles from being initialized before high-res tiles. | |
619 if (pending_is_low_res) | |
620 tree_bin[PENDING_TREE] = std::max(tree_bin[PENDING_TREE], EVENTUALLY_BIN); | |
621 | |
622 TilePriority tile_priority; | |
623 switch (tree_priority) { | |
624 case SAME_PRIORITY_FOR_BOTH_TREES: | |
625 mts.bin = std::min(tree_bin[ACTIVE_TREE], tree_bin[PENDING_TREE]); | |
626 tile_priority = tile->combined_priority(); | |
627 break; | |
628 case SMOOTHNESS_TAKES_PRIORITY: | |
629 mts.bin = tree_bin[ACTIVE_TREE]; | |
630 tile_priority = active_priority; | |
631 break; | |
632 case NEW_CONTENT_TAKES_PRIORITY: | |
633 mts.bin = tree_bin[PENDING_TREE]; | |
634 tile_priority = pending_priority; | |
635 break; | |
636 } | |
637 | |
638 // Bump up the priority if we determined it's NEVER_BIN on one tree, | |
639 // but is still required on the other tree. | |
640 bool is_in_never_bin_on_both_trees = tree_bin[ACTIVE_TREE] == NEVER_BIN && | |
641 tree_bin[PENDING_TREE] == NEVER_BIN; | |
642 | |
643 if (mts.bin == NEVER_BIN && !is_in_never_bin_on_both_trees) | |
644 mts.bin = tile_is_active ? AT_LAST_AND_ACTIVE_BIN : AT_LAST_BIN; | |
645 | |
646 mts.resolution = tile_priority.resolution; | |
647 mts.priority_bin = tile_priority.priority_bin; | |
648 mts.distance_to_visible = tile_priority.distance_to_visible; | |
649 mts.required_for_activation = tile_priority.required_for_activation; | |
650 | |
651 mts.visible_and_ready_to_draw = | |
652 tree_bin[ACTIVE_TREE] == NOW_AND_READY_TO_DRAW_BIN; | |
653 | |
654 // Tiles that are required for activation shouldn't be in NEVER_BIN unless | |
655 // smoothness takes priority or memory policy allows nothing to be | |
656 // initialized. | |
657 DCHECK(!mts.required_for_activation || mts.bin != NEVER_BIN || | |
658 tree_priority == SMOOTHNESS_TAKES_PRIORITY || | |
659 memory_policy == ALLOW_NOTHING); | |
660 | |
661 // If the tile is in NEVER_BIN and it does not have an active task, then we | |
662 // can release the resources early. If it does have the task however, we | |
663 // should keep it in the prioritized tile set to ensure that AssignGpuMemory | |
664 // can visit it. | |
665 if (mts.bin == NEVER_BIN && | |
666 !mts.tile_versions[mts.raster_mode].raster_task_) { | |
667 FreeResourcesForTile(tile); | |
668 continue; | |
669 } | |
670 | |
671 // Insert the tile into a priority set. | |
672 tiles->InsertTile(tile, mts.bin); | |
673 } | |
674 } | |
675 | |
676 void TileManager::CleanUpLayers() { | 427 void TileManager::CleanUpLayers() { |
677 for (size_t i = 0; i < layers_.size(); ++i) { | 428 for (size_t i = 0; i < layers_.size(); ++i) { |
678 if (layers_[i]->IsDrawnRenderSurfaceLayerListMember()) | 429 if (layers_[i]->IsDrawnRenderSurfaceLayerListMember()) |
679 continue; | 430 continue; |
680 | 431 |
681 layers_[i]->DidUnregisterLayer(); | 432 layers_[i]->DidUnregisterLayer(); |
682 std::swap(layers_[i], layers_.back()); | 433 std::swap(layers_[i], layers_.back()); |
683 layers_.pop_back(); | 434 layers_.pop_back(); |
684 --i; | 435 --i; |
685 prioritized_tiles_dirty_ = true; | |
686 } | 436 } |
687 } | 437 } |
688 | 438 |
689 void TileManager::ManageTiles(const GlobalStateThatImpactsTilePriority& state) { | 439 void TileManager::ManageTiles(const GlobalStateThatImpactsTilePriority& state) { |
690 TRACE_EVENT0("cc", "TileManager::ManageTiles"); | 440 TRACE_EVENT0("cc", "TileManager::ManageTiles"); |
691 | 441 |
692 // Update internal state. | 442 // Update internal state. |
693 if (state != global_state_) { | 443 global_state_ = state; |
694 global_state_ = state; | |
695 prioritized_tiles_dirty_ = true; | |
696 } | |
697 | 444 |
698 CleanUpLayers(); | 445 CleanUpLayers(); |
699 | 446 |
447 // TODO(vmpstr): See if we still need to keep tiles alive when layers release | |
448 // them. | |
449 CleanUpReleasedTiles(); | |
450 | |
700 // We need to call CheckForCompletedTasks() once in-between each call | 451 // We need to call CheckForCompletedTasks() once in-between each call |
701 // to ScheduleTasks() to prevent canceled tasks from being scheduled. | 452 // to ScheduleTasks() to prevent canceled tasks from being scheduled. |
702 if (!did_check_for_completed_tasks_since_last_schedule_tasks_) { | 453 if (!did_check_for_completed_tasks_since_last_schedule_tasks_) { |
703 rasterizer_->CheckForCompletedTasks(); | 454 rasterizer_->CheckForCompletedTasks(); |
704 did_check_for_completed_tasks_since_last_schedule_tasks_ = true; | 455 did_check_for_completed_tasks_since_last_schedule_tasks_ = true; |
705 } | 456 } |
706 | 457 |
707 UpdatePrioritizedTileSetIfNeeded(); | |
708 | |
709 TileVector tiles_that_need_to_be_rasterized; | 458 TileVector tiles_that_need_to_be_rasterized; |
710 AssignGpuMemoryToTiles(&prioritized_tiles_, | 459 AssignGpuMemoryToTiles(&tiles_that_need_to_be_rasterized); |
711 &tiles_that_need_to_be_rasterized); | |
712 | 460 |
713 // Finally, schedule rasterizer tasks. | 461 // Finally, schedule rasterizer tasks. |
714 ScheduleTasks(tiles_that_need_to_be_rasterized); | 462 ScheduleTasks(tiles_that_need_to_be_rasterized); |
715 | 463 |
716 TRACE_EVENT_INSTANT1("cc", | 464 TRACE_EVENT_INSTANT1("cc", |
717 "DidManage", | 465 "DidManage", |
718 TRACE_EVENT_SCOPE_THREAD, | 466 TRACE_EVENT_SCOPE_THREAD, |
719 "state", | 467 "state", |
720 TracedValue::FromValue(BasicStateAsValue().release())); | 468 TracedValue::FromValue(BasicStateAsValue().release())); |
721 | 469 |
(...skipping 21 matching lines...) Expand all Loading... | |
743 | 491 |
744 bool did_initialize_visible_tile = did_initialize_visible_tile_; | 492 bool did_initialize_visible_tile = did_initialize_visible_tile_; |
745 did_initialize_visible_tile_ = false; | 493 did_initialize_visible_tile_ = false; |
746 return did_initialize_visible_tile; | 494 return did_initialize_visible_tile; |
747 } | 495 } |
748 | 496 |
749 void TileManager::GetMemoryStats(size_t* memory_required_bytes, | 497 void TileManager::GetMemoryStats(size_t* memory_required_bytes, |
750 size_t* memory_nice_to_have_bytes, | 498 size_t* memory_nice_to_have_bytes, |
751 size_t* memory_allocated_bytes, | 499 size_t* memory_allocated_bytes, |
752 size_t* memory_used_bytes) const { | 500 size_t* memory_used_bytes) const { |
753 *memory_required_bytes = memory_required_bytes_; | 501 *memory_required_bytes = resource_pool_->total_memory_usage_bytes(); |
754 *memory_nice_to_have_bytes = memory_nice_to_have_bytes_; | 502 *memory_nice_to_have_bytes = resource_pool_->total_memory_usage_bytes(); |
755 *memory_allocated_bytes = resource_pool_->total_memory_usage_bytes(); | 503 *memory_allocated_bytes = resource_pool_->total_memory_usage_bytes(); |
756 *memory_used_bytes = resource_pool_->acquired_memory_usage_bytes(); | 504 *memory_used_bytes = resource_pool_->acquired_memory_usage_bytes(); |
757 } | 505 } |
758 | 506 |
759 scoped_ptr<base::Value> TileManager::BasicStateAsValue() const { | 507 scoped_ptr<base::Value> TileManager::BasicStateAsValue() const { |
760 scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue()); | 508 scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue()); |
761 state->SetInteger("tile_count", tiles_.size()); | 509 state->SetInteger("tile_count", tiles_.size()); |
762 state->Set("global_state", global_state_.AsValue().release()); | 510 state->Set("global_state", global_state_.AsValue().release()); |
763 state->Set("memory_requirements", GetMemoryRequirementsAsValue().release()); | 511 state->Set("memory_requirements", GetMemoryRequirementsAsValue().release()); |
764 return state.PassAs<base::Value>(); | 512 return state.PassAs<base::Value>(); |
(...skipping 19 matching lines...) Expand all Loading... | |
784 &memory_allocated_bytes, | 532 &memory_allocated_bytes, |
785 &memory_used_bytes); | 533 &memory_used_bytes); |
786 requirements->SetInteger("memory_required_bytes", memory_required_bytes); | 534 requirements->SetInteger("memory_required_bytes", memory_required_bytes); |
787 requirements->SetInteger("memory_nice_to_have_bytes", | 535 requirements->SetInteger("memory_nice_to_have_bytes", |
788 memory_nice_to_have_bytes); | 536 memory_nice_to_have_bytes); |
789 requirements->SetInteger("memory_allocated_bytes", memory_allocated_bytes); | 537 requirements->SetInteger("memory_allocated_bytes", memory_allocated_bytes); |
790 requirements->SetInteger("memory_used_bytes", memory_used_bytes); | 538 requirements->SetInteger("memory_used_bytes", memory_used_bytes); |
791 return requirements.PassAs<base::Value>(); | 539 return requirements.PassAs<base::Value>(); |
792 } | 540 } |
793 | 541 |
542 bool TileManager::FreeTileResourcesUntilUsageIsWithinBudget( | |
543 EvictionTileIterator* eviction_iterator, | |
544 const MemoryBudget& required_budget, | |
545 MemoryBudget* current_budget, | |
546 const TilePriority& max_priority, | |
547 bool evict_unconditionally) { | |
548 bool evicted_tiles_required_for_activation = false; | |
549 while (required_budget.Exceeds(*current_budget)) { | |
550 if (!*eviction_iterator) | |
551 break; | |
552 | |
553 Tile* eviction_tile = **eviction_iterator; | |
554 DCHECK(eviction_tile); | |
555 | |
556 TilePriority eviction_priority = | |
557 eviction_tile->priority_for_tree_priority(global_state_.tree_priority); | |
558 | |
559 if (!evict_unconditionally && | |
560 !max_priority.IsHigherPriorityThan(eviction_priority)) | |
561 break; | |
562 | |
563 size_t eviction_bytes_if_allocated = | |
564 BytesConsumedIfAllocated(eviction_tile); | |
565 ManagedTileState& eviction_mts = eviction_tile->managed_state(); | |
566 for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) { | |
567 if (eviction_mts.tile_versions[mode].resource_) { | |
568 current_budget->hard_memory_bytes += eviction_bytes_if_allocated; | |
569 if (eviction_priority.priority_bin != TilePriority::NOW) | |
570 current_budget->soft_memory_bytes += eviction_bytes_if_allocated; | |
571 current_budget->resource_count++; | |
572 } | |
573 } | |
574 FreeResourcesForTile(eviction_tile); | |
575 ++(*eviction_iterator); | |
576 | |
577 evicted_tiles_required_for_activation |= | |
578 eviction_tile->required_for_activation(); | |
579 } | |
580 return evicted_tiles_required_for_activation; | |
581 } | |
582 | |
583 bool TileManager::TilePriorityViolatesMemoryPolicy( | |
584 const TilePriority& priority) { | |
585 switch (global_state_.memory_limit_policy) { | |
586 case ALLOW_NOTHING: | |
587 return true; | |
588 case ALLOW_ABSOLUTE_MINIMUM: | |
589 return priority.priority_bin > TilePriority::NOW; | |
590 case ALLOW_PREPAINT_ONLY: | |
591 return priority.priority_bin > TilePriority::SOON; | |
592 case ALLOW_ANYTHING: | |
593 return priority.distance_to_visible == | |
594 std::numeric_limits<float>::infinity(); | |
595 case NUM_TILE_MEMORY_LIMIT_POLICIES: | |
reveman
2014/05/28 16:04:12
Please remove NUM_TILE_MEMORY_LIMIT_POLICIES and m
| |
596 NOTREACHED(); | |
597 break; | |
598 } | |
599 return true; | |
600 } | |
601 | |
794 void TileManager::AssignGpuMemoryToTiles( | 602 void TileManager::AssignGpuMemoryToTiles( |
795 PrioritizedTileSet* tiles, | |
796 TileVector* tiles_that_need_to_be_rasterized) { | 603 TileVector* tiles_that_need_to_be_rasterized) { |
797 TRACE_EVENT0("cc", "TileManager::AssignGpuMemoryToTiles"); | 604 TRACE_EVENT0("cc", "TileManager::AssignGpuMemoryToTiles"); |
798 | 605 |
799 // Maintain the list of released resources that can potentially be re-used | 606 // Maintain the list of released resources that can potentially be re-used |
800 // or deleted. | 607 // or deleted. |
801 // If this operation becomes expensive too, only do this after some | 608 // If this operation becomes expensive too, only do this after some |
802 // resource(s) was returned. Note that in that case, one also need to | 609 // resource(s) was returned. Note that in that case, one also need to |
803 // invalidate when releasing some resource from the pool. | 610 // invalidate when releasing some resource from the pool. |
804 resource_pool_->CheckBusyResources(); | 611 resource_pool_->CheckBusyResources(); |
805 | 612 |
806 // Now give memory out to the tiles until we're out, and build | 613 // Now give memory out to the tiles until we're out, and build |
807 // the needs-to-be-rasterized queue. | 614 // the needs-to-be-rasterized queue. |
808 all_tiles_that_need_to_be_rasterized_have_memory_ = true; | 615 all_tiles_that_need_to_be_rasterized_have_memory_ = true; |
809 all_tiles_required_for_activation_have_memory_ = true; | 616 all_tiles_required_for_activation_have_memory_ = true; |
810 | 617 |
618 MemoryBudget budget; | |
811 // Cast to prevent overflow. | 619 // Cast to prevent overflow. |
812 int64 soft_bytes_available = | 620 budget.soft_memory_bytes = |
813 static_cast<int64>(bytes_releasable_) + | |
814 static_cast<int64>(global_state_.soft_memory_limit_in_bytes) - | 621 static_cast<int64>(global_state_.soft_memory_limit_in_bytes) - |
815 static_cast<int64>(resource_pool_->acquired_memory_usage_bytes()); | 622 static_cast<int64>(resource_pool_->acquired_memory_usage_bytes()); |
816 int64 hard_bytes_available = | 623 budget.hard_memory_bytes = |
817 static_cast<int64>(bytes_releasable_) + | |
818 static_cast<int64>(global_state_.hard_memory_limit_in_bytes) - | 624 static_cast<int64>(global_state_.hard_memory_limit_in_bytes) - |
819 static_cast<int64>(resource_pool_->acquired_memory_usage_bytes()); | 625 static_cast<int64>(resource_pool_->acquired_memory_usage_bytes()); |
820 int resources_available = resources_releasable_ + | 626 budget.resource_count = global_state_.num_resources_limit - |
821 global_state_.num_resources_limit - | 627 resource_pool_->acquired_resource_count(); |
822 resource_pool_->acquired_resource_count(); | 628 |
823 size_t soft_bytes_allocatable = | 629 MemoryBudget initial_budget = budget; |
824 std::max(static_cast<int64>(0), soft_bytes_available); | 630 |
825 size_t hard_bytes_allocatable = | 631 EvictionTileIterator eviction_it(this, global_state_.tree_priority); |
826 std::max(static_cast<int64>(0), hard_bytes_available); | 632 |
827 size_t resources_allocatable = std::max(0, resources_available); | 633 MemoryBudget required_budget; |
634 required_budget.soft_memory_bytes = 0; | |
635 required_budget.hard_memory_bytes = 0; | |
636 required_budget.resource_count = 0; | |
637 | |
638 bool evicted_tiles_required_for_activation = | |
639 FreeTileResourcesUntilUsageIsWithinBudget( | |
640 &eviction_it, required_budget, &budget, TilePriority(), true); | |
828 | 641 |
829 size_t bytes_that_exceeded_memory_budget = 0; | 642 size_t bytes_that_exceeded_memory_budget = 0; |
830 size_t soft_bytes_left = soft_bytes_allocatable; | |
831 size_t hard_bytes_left = hard_bytes_allocatable; | |
832 | 643 |
833 size_t resources_left = resources_allocatable; | |
834 bool oomed_soft = false; | 644 bool oomed_soft = false; |
835 bool oomed_hard = false; | 645 bool oomed_hard = false; |
836 bool have_hit_soft_memory = false; // Soft memory comes after hard. | 646 bool have_hit_soft_memory = false; // Soft memory comes after hard. |
837 | 647 |
838 unsigned schedule_priority = 1u; | 648 unsigned schedule_priority = 1u; |
839 for (PrioritizedTileSet::Iterator it(tiles, true); it; ++it) { | 649 for (RasterTileIterator it(this, global_state_.tree_priority); it; ++it) { |
840 Tile* tile = *it; | 650 Tile* tile = *it; |
651 TilePriority priority = | |
652 tile->priority_for_tree_priority(global_state_.tree_priority); | |
653 | |
654 if (TilePriorityViolatesMemoryPolicy(priority)) | |
655 break; | |
656 | |
841 ManagedTileState& mts = tile->managed_state(); | 657 ManagedTileState& mts = tile->managed_state(); |
842 | 658 |
843 mts.scheduled_priority = schedule_priority++; | 659 mts.scheduled_priority = schedule_priority++; |
844 | 660 |
845 mts.raster_mode = tile->DetermineOverallRasterMode(); | 661 mts.raster_mode = tile->DetermineOverallRasterMode(); |
846 | 662 |
847 ManagedTileState::TileVersion& tile_version = | 663 ManagedTileState::TileVersion& tile_version = |
848 mts.tile_versions[mts.raster_mode]; | 664 mts.tile_versions[mts.raster_mode]; |
849 | 665 |
850 // If this tile doesn't need a resource, then nothing to do. | 666 // If this tile version is ready to draw, then nothing to do. |
851 if (!tile_version.requires_resource()) | 667 if (tile_version.IsReadyToDraw()) |
852 continue; | 668 continue; |
853 | 669 |
854 // If the tile is not needed, free it up. | 670 const bool tile_uses_hard_limit = |
855 if (mts.bin == NEVER_BIN) { | 671 priority.priority_bin == TilePriority::NOW; |
856 FreeResourcesForTile(tile); | |
857 continue; | |
858 } | |
859 | |
860 const bool tile_uses_hard_limit = mts.bin <= NOW_BIN; | |
861 const size_t bytes_if_allocated = BytesConsumedIfAllocated(tile); | 672 const size_t bytes_if_allocated = BytesConsumedIfAllocated(tile); |
862 const size_t tile_bytes_left = | |
863 (tile_uses_hard_limit) ? hard_bytes_left : soft_bytes_left; | |
864 | 673 |
865 // Hard-limit is reserved for tiles that would cause a calamity | 674 // Hard-limit is reserved for tiles that would cause a calamity |
866 // if they were to go away, so by definition they are the highest | 675 // if they were to go away, so by definition they are the highest |
867 // priority memory, and must be at the front of the list. | 676 // priority memory, and must be at the front of the list. |
868 DCHECK(!(have_hit_soft_memory && tile_uses_hard_limit)); | 677 DCHECK(!(have_hit_soft_memory && tile_uses_hard_limit)); |
869 have_hit_soft_memory |= !tile_uses_hard_limit; | 678 have_hit_soft_memory |= !tile_uses_hard_limit; |
870 | 679 |
871 size_t tile_bytes = 0; | 680 int64 tile_bytes = 0; |
872 size_t tile_resources = 0; | 681 int tile_resources = 0; |
873 | 682 |
874 // It costs to maintain a resource. | 683 // It costs to maintain a resource. |
875 for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) { | 684 for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) { |
876 if (mts.tile_versions[mode].resource_) { | 685 if (mts.tile_versions[mode].resource_) { |
877 tile_bytes += bytes_if_allocated; | 686 tile_bytes += bytes_if_allocated; |
878 tile_resources++; | 687 tile_resources++; |
879 } | 688 } |
880 } | 689 } |
881 | 690 |
882 // Allow lower priority tiles with initialized resources to keep | 691 // If we don't have the required version, and it's not in flight |
883 // their memory by only assigning memory to new raster tasks if | 692 // then we'll have to pay to create a new task. |
884 // they can be scheduled. | 693 if (!tile_version.resource_ && !tile_version.raster_task_) { |
885 bool reached_scheduled_raster_tasks_limit = | 694 tile_bytes += bytes_if_allocated; |
886 tiles_that_need_to_be_rasterized->size() >= kScheduledRasterTasksLimit; | 695 tile_resources++; |
887 if (!reached_scheduled_raster_tasks_limit) { | |
888 // If we don't have the required version, and it's not in flight | |
889 // then we'll have to pay to create a new task. | |
890 if (!tile_version.resource_ && !tile_version.raster_task_) { | |
891 tile_bytes += bytes_if_allocated; | |
892 tile_resources++; | |
893 } | |
894 } | 696 } |
895 | 697 |
896 // Tile is OOM. | 698 required_budget.soft_memory_bytes = 0; |
897 if (tile_bytes > tile_bytes_left || tile_resources > resources_left) { | 699 required_budget.hard_memory_bytes = 0; |
700 required_budget.resource_count = tile_resources; | |
701 if (tile_uses_hard_limit) | |
702 required_budget.hard_memory_bytes = tile_bytes; | |
703 else | |
704 required_budget.soft_memory_bytes = tile_bytes; | |
705 | |
706 // Handle OOM tiles. | |
707 evicted_tiles_required_for_activation = | |
708 FreeTileResourcesUntilUsageIsWithinBudget( | |
709 &eviction_it, required_budget, &budget, priority, false) || | |
710 evicted_tiles_required_for_activation; | |
711 | |
712 // Tile is still OOM. | |
713 if (required_budget.Exceeds(budget)) { | |
898 FreeResourcesForTile(tile); | 714 FreeResourcesForTile(tile); |
899 | 715 |
900 // This tile was already on screen and now its resources have been | 716 // This tile was already on screen and now its resources have been |
901 // released. In order to prevent checkerboarding, set this tile as | 717 // released. In order to prevent checkerboarding, set this tile as |
902 // rasterize on demand immediately. | 718 // rasterize on demand immediately. |
903 if (mts.visible_and_ready_to_draw && use_rasterize_on_demand_) | 719 if (mts.visible_and_ready_to_draw && use_rasterize_on_demand_) |
904 tile_version.set_rasterize_on_demand(); | 720 tile_version.set_rasterize_on_demand(); |
905 | 721 |
906 oomed_soft = true; | 722 oomed_soft = true; |
907 if (tile_uses_hard_limit) { | 723 if (tile_uses_hard_limit) { |
908 oomed_hard = true; | 724 oomed_hard = true; |
909 bytes_that_exceeded_memory_budget += tile_bytes; | 725 bytes_that_exceeded_memory_budget += tile_bytes; |
910 } | 726 } |
911 } else { | 727 } else { |
912 resources_left -= tile_resources; | 728 budget.resource_count -= tile_resources; |
913 hard_bytes_left -= tile_bytes; | 729 budget.hard_memory_bytes -= tile_bytes; |
914 soft_bytes_left = | 730 budget.soft_memory_bytes = (budget.soft_memory_bytes > tile_bytes) |
915 (soft_bytes_left > tile_bytes) ? soft_bytes_left - tile_bytes : 0; | 731 ? budget.soft_memory_bytes - tile_bytes |
732 : 0; | |
916 if (tile_version.resource_) | 733 if (tile_version.resource_) |
917 continue; | 734 continue; |
918 } | 735 } |
919 | 736 |
920 DCHECK(!tile_version.resource_); | 737 DCHECK(!tile_version.resource_); |
921 | 738 |
922 // Tile shouldn't be rasterized if |tiles_that_need_to_be_rasterized| | 739 // Tile shouldn't be rasterized if |tiles_that_need_to_be_rasterized| |
923 // has reached it's limit or we've failed to assign gpu memory to this | 740 // has reached it's limit or we've failed to assign gpu memory to this |
924 // or any higher priority tile. Preventing tiles that fit into memory | 741 // or any higher priority tile. Preventing tiles that fit into memory |
925 // budget to be rasterized when higher priority tile is oom is | 742 // budget to be rasterized when higher priority tile is oom is |
926 // important for two reasons: | 743 // important for two reasons: |
927 // 1. Tile size should not impact raster priority. | 744 // 1. Tile size should not impact raster priority. |
928 // 2. Tiles with existing raster task could otherwise incorrectly | 745 // 2. Tiles with existing raster task could otherwise incorrectly |
929 // be added as they are not affected by |bytes_allocatable|. | 746 // be added as they are not affected by |bytes_allocatable|. |
930 bool can_schedule_tile = | 747 bool can_schedule_tile = |
931 !oomed_soft && !reached_scheduled_raster_tasks_limit; | 748 !oomed_soft && |
749 tiles_that_need_to_be_rasterized->size() < kScheduledRasterTasksLimit; | |
932 | 750 |
933 if (!can_schedule_tile) { | 751 if (!can_schedule_tile) { |
934 all_tiles_that_need_to_be_rasterized_have_memory_ = false; | 752 all_tiles_that_need_to_be_rasterized_have_memory_ = false; |
935 if (tile->required_for_activation()) | 753 all_tiles_required_for_activation_have_memory_ = |
reveman
2014/05/28 16:04:12
I don't think all_tiles_required_for_activation_ha
| |
936 all_tiles_required_for_activation_have_memory_ = false; | 754 !it.HasTilesRequiredForActivation() && |
937 it.DisablePriorityOrdering(); | 755 !evicted_tiles_required_for_activation; |
938 continue; | 756 break; |
939 } | 757 } |
940 | 758 |
941 tiles_that_need_to_be_rasterized->push_back(tile); | 759 tiles_that_need_to_be_rasterized->push_back(tile); |
942 } | 760 } |
943 | 761 |
944 // OOM reporting uses hard-limit, soft-OOM is normal depending on limit. | 762 // OOM reporting uses hard-limit, soft-OOM is normal depending on limit. |
945 ever_exceeded_memory_budget_ |= oomed_hard; | 763 ever_exceeded_memory_budget_ |= oomed_hard; |
946 if (ever_exceeded_memory_budget_) { | 764 if (ever_exceeded_memory_budget_) { |
947 TRACE_COUNTER_ID2("cc", | 765 TRACE_COUNTER_ID2("cc", |
948 "over_memory_budget", | 766 "over_memory_budget", |
949 this, | 767 this, |
950 "budget", | 768 "budget", |
951 global_state_.hard_memory_limit_in_bytes, | 769 global_state_.hard_memory_limit_in_bytes, |
952 "over", | 770 "over", |
953 bytes_that_exceeded_memory_budget); | 771 bytes_that_exceeded_memory_budget); |
954 } | 772 } |
955 memory_stats_from_last_assign_.total_budget_in_bytes = | 773 memory_stats_from_last_assign_.total_budget_in_bytes = |
956 global_state_.hard_memory_limit_in_bytes; | 774 global_state_.hard_memory_limit_in_bytes; |
957 memory_stats_from_last_assign_.bytes_allocated = | 775 memory_stats_from_last_assign_.bytes_allocated = |
958 hard_bytes_allocatable - hard_bytes_left; | 776 initial_budget.hard_memory_bytes - budget.hard_memory_bytes; |
959 memory_stats_from_last_assign_.bytes_unreleasable = | 777 memory_stats_from_last_assign_.bytes_unreleasable = |
960 resource_pool_->acquired_memory_usage_bytes() - bytes_releasable_; | 778 resource_pool_->acquired_memory_usage_bytes() - bytes_releasable_; |
961 memory_stats_from_last_assign_.bytes_over = bytes_that_exceeded_memory_budget; | 779 memory_stats_from_last_assign_.bytes_over = bytes_that_exceeded_memory_budget; |
962 } | 780 } |
963 | 781 |
964 void TileManager::FreeResourceForTile(Tile* tile, RasterMode mode) { | 782 void TileManager::FreeResourceForTile(Tile* tile, RasterMode mode) { |
965 ManagedTileState& mts = tile->managed_state(); | 783 ManagedTileState& mts = tile->managed_state(); |
966 if (mts.tile_versions[mode].resource_) { | 784 if (mts.tile_versions[mode].resource_) { |
967 resource_pool_->ReleaseResource(mts.tile_versions[mode].resource_.Pass()); | 785 resource_pool_->ReleaseResource(mts.tile_versions[mode].resource_.Pass()); |
968 | 786 |
(...skipping 241 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1210 content_rect, | 1028 content_rect, |
1211 opaque_rect, | 1029 opaque_rect, |
1212 contents_scale, | 1030 contents_scale, |
1213 layer_id, | 1031 layer_id, |
1214 source_frame_number, | 1032 source_frame_number, |
1215 flags)); | 1033 flags)); |
1216 DCHECK(tiles_.find(tile->id()) == tiles_.end()); | 1034 DCHECK(tiles_.find(tile->id()) == tiles_.end()); |
1217 | 1035 |
1218 tiles_[tile->id()] = tile; | 1036 tiles_[tile->id()] = tile; |
1219 used_layer_counts_[tile->layer_id()]++; | 1037 used_layer_counts_[tile->layer_id()]++; |
1220 prioritized_tiles_dirty_ = true; | |
1221 return tile; | 1038 return tile; |
1222 } | 1039 } |
1223 | 1040 |
1224 void TileManager::RegisterPictureLayerImpl(PictureLayerImpl* layer) { | 1041 void TileManager::RegisterPictureLayerImpl(PictureLayerImpl* layer) { |
1225 DCHECK(std::find(layers_.begin(), layers_.end(), layer) == layers_.end()); | 1042 DCHECK(std::find(layers_.begin(), layers_.end(), layer) == layers_.end()); |
1226 layers_.push_back(layer); | 1043 layers_.push_back(layer); |
1227 } | 1044 } |
1228 | 1045 |
1229 void TileManager::UnregisterPictureLayerImpl(PictureLayerImpl* layer) { | 1046 void TileManager::UnregisterPictureLayerImpl(PictureLayerImpl* layer) { |
1230 std::vector<PictureLayerImpl*>::iterator it = | 1047 std::vector<PictureLayerImpl*>::iterator it = |
(...skipping 14 matching lines...) Expand all Loading... | |
1245 PictureLayerImpl* layer = *it; | 1062 PictureLayerImpl* layer = *it; |
1246 | 1063 |
1247 // This is a recycle tree layer, we can safely skip since the tiles on this | 1064 // This is a recycle tree layer, we can safely skip since the tiles on this |
1248 // layer have to be accessible via the active tree. | 1065 // layer have to be accessible via the active tree. |
1249 if (!layer->IsOnActiveOrPendingTree()) | 1066 if (!layer->IsOnActiveOrPendingTree()) |
1250 continue; | 1067 continue; |
1251 | 1068 |
1252 PictureLayerImpl* twin_layer = layer->GetTwinLayer(); | 1069 PictureLayerImpl* twin_layer = layer->GetTwinLayer(); |
1253 | 1070 |
1254 // If the twin layer is recycled, it is not a valid twin. | 1071 // If the twin layer is recycled, it is not a valid twin. |
1255 if (twin_layer && !twin_layer->IsOnActiveOrPendingTree()) | 1072 // Note another case twin is not valid is if it wasn't yet registered in |
1073 // this tile manager. This can happen at the start of a new page when we | |
1074 // only update the pending tree's priority after the first commit. | |
1075 if (twin_layer && (!twin_layer->IsOnActiveOrPendingTree() || | |
1076 !twin_layer->LayerRegisteredInTileManager())) { | |
1256 twin_layer = NULL; | 1077 twin_layer = NULL; |
1078 } | |
1257 | 1079 |
1258 PairedPictureLayer paired_layer; | 1080 PairedPictureLayer paired_layer; |
1259 WhichTree tree = layer->GetTree(); | 1081 WhichTree tree = layer->GetTree(); |
1260 | 1082 |
1261 // If the current tree is ACTIVE_TREE, then always generate a paired_layer. | 1083 // If the current tree is ACTIVE_TREE, then always generate a paired_layer. |
1262 // If current tree is PENDING_TREE, then only generate a paired_layer if | 1084 // If current tree is PENDING_TREE, then only generate a paired_layer if |
1263 // there is no twin layer. | 1085 // there is no twin layer. |
1264 if (tree == ACTIVE_TREE) { | 1086 if (tree == ACTIVE_TREE) { |
1265 DCHECK(!twin_layer || twin_layer->GetTree() == PENDING_TREE); | 1087 DCHECK(!twin_layer || twin_layer->GetTree() == PENDING_TREE); |
1266 paired_layer.active_layer = layer; | 1088 paired_layer.active_layer = layer; |
(...skipping 42 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1309 paired_iterators_.push_back(paired_iterator); | 1131 paired_iterators_.push_back(paired_iterator); |
1310 iterator_heap_.push_back(&paired_iterators_.back()); | 1132 iterator_heap_.push_back(&paired_iterators_.back()); |
1311 } | 1133 } |
1312 } | 1134 } |
1313 | 1135 |
1314 std::make_heap(iterator_heap_.begin(), iterator_heap_.end(), comparator_); | 1136 std::make_heap(iterator_heap_.begin(), iterator_heap_.end(), comparator_); |
1315 } | 1137 } |
1316 | 1138 |
1317 TileManager::RasterTileIterator::~RasterTileIterator() {} | 1139 TileManager::RasterTileIterator::~RasterTileIterator() {} |
1318 | 1140 |
1141 bool TileManager::RasterTileIterator::HasTilesRequiredForActivation() const { | |
1142 for (std::vector<PairedPictureLayerIterator*>::const_iterator it = | |
1143 iterator_heap_.begin(); | |
1144 it != iterator_heap_.end(); | |
1145 ++it) { | |
1146 const PairedPictureLayerIterator* pair = *it; | |
1147 | |
1148 // Tiles required for activation can only come from pending layers. | |
1149 if (pair->pending_iterator.HasTilesRequiredForActivation()) | |
1150 return true; | |
1151 } | |
1152 return false; | |
1153 } | |
1154 | |
1319 TileManager::RasterTileIterator& TileManager::RasterTileIterator::operator++() { | 1155 TileManager::RasterTileIterator& TileManager::RasterTileIterator::operator++() { |
1320 DCHECK(*this); | 1156 DCHECK(*this); |
1321 | 1157 |
1322 std::pop_heap(iterator_heap_.begin(), iterator_heap_.end(), comparator_); | 1158 std::pop_heap(iterator_heap_.begin(), iterator_heap_.end(), comparator_); |
1323 PairedPictureLayerIterator* paired_iterator = iterator_heap_.back(); | 1159 PairedPictureLayerIterator* paired_iterator = iterator_heap_.back(); |
1324 iterator_heap_.pop_back(); | 1160 iterator_heap_.pop_back(); |
1325 | 1161 |
1326 paired_iterator->PopTile(tree_priority_); | 1162 paired_iterator->PopTile(tree_priority_); |
1327 if (paired_iterator->PeekTile(tree_priority_) != NULL) { | 1163 if (paired_iterator->PeekTile(tree_priority_) != NULL) { |
1328 iterator_heap_.push_back(paired_iterator); | 1164 iterator_heap_.push_back(paired_iterator); |
(...skipping 112 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1441 | 1277 |
1442 Tile* a_tile = **a_pair.first; | 1278 Tile* a_tile = **a_pair.first; |
1443 Tile* b_tile = **b_pair.first; | 1279 Tile* b_tile = **b_pair.first; |
1444 | 1280 |
1445 const TilePriority& a_priority = | 1281 const TilePriority& a_priority = |
1446 a_tile->priority_for_tree_priority(tree_priority_); | 1282 a_tile->priority_for_tree_priority(tree_priority_); |
1447 const TilePriority& b_priority = | 1283 const TilePriority& b_priority = |
1448 b_tile->priority_for_tree_priority(tree_priority_); | 1284 b_tile->priority_for_tree_priority(tree_priority_); |
1449 bool prioritize_low_res = tree_priority_ == SMOOTHNESS_TAKES_PRIORITY; | 1285 bool prioritize_low_res = tree_priority_ == SMOOTHNESS_TAKES_PRIORITY; |
1450 | 1286 |
1451 if (b_priority.resolution != a_priority.resolution) { | 1287 if (b_priority.priority_bin == a_priority.priority_bin && |
1288 b_priority.resolution != a_priority.resolution) { | |
1452 return (prioritize_low_res && b_priority.resolution == LOW_RESOLUTION) || | 1289 return (prioritize_low_res && b_priority.resolution == LOW_RESOLUTION) || |
1453 (!prioritize_low_res && b_priority.resolution == HIGH_RESOLUTION) || | 1290 (!prioritize_low_res && b_priority.resolution == HIGH_RESOLUTION) || |
1454 (a_priority.resolution == NON_IDEAL_RESOLUTION); | 1291 (a_priority.resolution == NON_IDEAL_RESOLUTION); |
1455 } | 1292 } |
1456 | 1293 |
1457 return b_priority.IsHigherPriorityThan(a_priority); | 1294 return b_priority.IsHigherPriorityThan(a_priority); |
1458 } | 1295 } |
1459 | 1296 |
1460 TileManager::EvictionTileIterator::EvictionTileIterator() | 1297 TileManager::EvictionTileIterator::EvictionTileIterator() |
1461 : comparator_(SAME_PRIORITY_FOR_BOTH_TREES) {} | 1298 : initialized_(true), |
1299 tile_manager_(NULL), | |
1300 comparator_(SAME_PRIORITY_FOR_BOTH_TREES) { | |
1301 } | |
1462 | 1302 |
1463 TileManager::EvictionTileIterator::EvictionTileIterator( | 1303 TileManager::EvictionTileIterator::EvictionTileIterator( |
1464 TileManager* tile_manager, | 1304 TileManager* tile_manager, |
1465 TreePriority tree_priority) | 1305 TreePriority tree_priority) |
1466 : tree_priority_(tree_priority), comparator_(tree_priority) { | 1306 : initialized_(false), |
1307 tile_manager_(tile_manager), | |
1308 tree_priority_(tree_priority), | |
1309 comparator_(tree_priority) { | |
1310 } | |
1311 | |
1312 void TileManager::EvictionTileIterator::Initialize() { | |
1467 std::vector<TileManager::PairedPictureLayer> paired_layers; | 1313 std::vector<TileManager::PairedPictureLayer> paired_layers; |
1468 | 1314 |
1469 tile_manager->GetPairedPictureLayers(&paired_layers); | 1315 tile_manager_->GetPairedPictureLayers(&paired_layers); |
1470 | 1316 |
1471 paired_iterators_.reserve(paired_layers.size()); | 1317 paired_iterators_.reserve(paired_layers.size()); |
1472 iterator_heap_.reserve(paired_layers.size()); | 1318 iterator_heap_.reserve(paired_layers.size()); |
1473 for (std::vector<TileManager::PairedPictureLayer>::iterator it = | 1319 for (std::vector<TileManager::PairedPictureLayer>::iterator it = |
1474 paired_layers.begin(); | 1320 paired_layers.begin(); |
1475 it != paired_layers.end(); | 1321 it != paired_layers.end(); |
1476 ++it) { | 1322 ++it) { |
1477 PairedPictureLayerIterator paired_iterator; | 1323 PairedPictureLayerIterator paired_iterator; |
1478 if (it->active_layer) { | 1324 if (it->active_layer) { |
1479 paired_iterator.active_iterator = | 1325 paired_iterator.active_iterator = |
1480 PictureLayerImpl::LayerEvictionTileIterator(it->active_layer, | 1326 PictureLayerImpl::LayerEvictionTileIterator(it->active_layer, |
1481 tree_priority_); | 1327 tree_priority_); |
1482 } | 1328 } |
1483 | 1329 |
1484 if (it->pending_layer) { | 1330 if (it->pending_layer) { |
1485 paired_iterator.pending_iterator = | 1331 paired_iterator.pending_iterator = |
1486 PictureLayerImpl::LayerEvictionTileIterator(it->pending_layer, | 1332 PictureLayerImpl::LayerEvictionTileIterator(it->pending_layer, |
1487 tree_priority_); | 1333 tree_priority_); |
1488 } | 1334 } |
1489 | 1335 |
1490 if (paired_iterator.PeekTile(tree_priority_) != NULL) { | 1336 if (paired_iterator.PeekTile(tree_priority_) != NULL) { |
1491 paired_iterators_.push_back(paired_iterator); | 1337 paired_iterators_.push_back(paired_iterator); |
1492 iterator_heap_.push_back(&paired_iterators_.back()); | 1338 iterator_heap_.push_back(&paired_iterators_.back()); |
1493 } | 1339 } |
1494 } | 1340 } |
1495 | 1341 |
1496 std::make_heap(iterator_heap_.begin(), iterator_heap_.end(), comparator_); | 1342 std::make_heap(iterator_heap_.begin(), iterator_heap_.end(), comparator_); |
1343 initialized_ = true; | |
1497 } | 1344 } |
1498 | 1345 |
1499 TileManager::EvictionTileIterator::~EvictionTileIterator() {} | 1346 TileManager::EvictionTileIterator::~EvictionTileIterator() {} |
1500 | 1347 |
1501 TileManager::EvictionTileIterator& TileManager::EvictionTileIterator:: | 1348 TileManager::EvictionTileIterator& TileManager::EvictionTileIterator:: |
1502 operator++() { | 1349 operator++() { |
1350 DCHECK(initialized_); | |
1351 | |
1503 std::pop_heap(iterator_heap_.begin(), iterator_heap_.end(), comparator_); | 1352 std::pop_heap(iterator_heap_.begin(), iterator_heap_.end(), comparator_); |
1504 PairedPictureLayerIterator* paired_iterator = iterator_heap_.back(); | 1353 PairedPictureLayerIterator* paired_iterator = iterator_heap_.back(); |
1505 iterator_heap_.pop_back(); | 1354 iterator_heap_.pop_back(); |
1506 | 1355 |
1507 paired_iterator->PopTile(tree_priority_); | 1356 paired_iterator->PopTile(tree_priority_); |
1508 if (paired_iterator->PeekTile(tree_priority_) != NULL) { | 1357 if (paired_iterator->PeekTile(tree_priority_) != NULL) { |
1509 iterator_heap_.push_back(paired_iterator); | 1358 iterator_heap_.push_back(paired_iterator); |
1510 std::push_heap(iterator_heap_.begin(), iterator_heap_.end(), comparator_); | 1359 std::push_heap(iterator_heap_.begin(), iterator_heap_.end(), comparator_); |
1511 } | 1360 } |
1512 return *this; | 1361 return *this; |
1513 } | 1362 } |
1514 | 1363 |
1515 TileManager::EvictionTileIterator::operator bool() const { | 1364 TileManager::EvictionTileIterator::operator bool() { |
1365 if (!initialized_) | |
1366 Initialize(); | |
1367 | |
1516 return !iterator_heap_.empty(); | 1368 return !iterator_heap_.empty(); |
1517 } | 1369 } |
1518 | 1370 |
1519 Tile* TileManager::EvictionTileIterator::operator*() { | 1371 Tile* TileManager::EvictionTileIterator::operator*() { |
1372 DCHECK(initialized_); | |
1520 DCHECK(*this); | 1373 DCHECK(*this); |
1521 return iterator_heap_.front()->PeekTile(tree_priority_); | 1374 return iterator_heap_.front()->PeekTile(tree_priority_); |
1522 } | 1375 } |
1523 | 1376 |
1524 TileManager::EvictionTileIterator::PairedPictureLayerIterator:: | 1377 TileManager::EvictionTileIterator::PairedPictureLayerIterator:: |
1525 PairedPictureLayerIterator() {} | 1378 PairedPictureLayerIterator() {} |
1526 | 1379 |
1527 TileManager::EvictionTileIterator::PairedPictureLayerIterator:: | 1380 TileManager::EvictionTileIterator::PairedPictureLayerIterator:: |
1528 ~PairedPictureLayerIterator() {} | 1381 ~PairedPictureLayerIterator() {} |
1529 | 1382 |
(...skipping 91 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1621 } | 1474 } |
1622 return a_priority.IsHigherPriorityThan(b_priority); | 1475 return a_priority.IsHigherPriorityThan(b_priority); |
1623 } | 1476 } |
1624 | 1477 |
1625 void TileManager::SetRasterizerForTesting(Rasterizer* rasterizer) { | 1478 void TileManager::SetRasterizerForTesting(Rasterizer* rasterizer) { |
1626 rasterizer_ = rasterizer; | 1479 rasterizer_ = rasterizer; |
1627 rasterizer_->SetClient(this); | 1480 rasterizer_->SetClient(this); |
1628 } | 1481 } |
1629 | 1482 |
1630 } // namespace cc | 1483 } // namespace cc |
OLD | NEW |