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 152 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
163 | 163 |
164 void TileManager::UnregisterTile(Tile* tile) { | 164 void TileManager::UnregisterTile(Tile* tile) { |
165 TileVector::iterator raster_iter = | 165 TileVector::iterator raster_iter = |
166 std::find(tiles_that_need_to_be_rasterized_.begin(), | 166 std::find(tiles_that_need_to_be_rasterized_.begin(), |
167 tiles_that_need_to_be_rasterized_.end(), | 167 tiles_that_need_to_be_rasterized_.end(), |
168 tile); | 168 tile); |
169 if (raster_iter != tiles_that_need_to_be_rasterized_.end()) | 169 if (raster_iter != tiles_that_need_to_be_rasterized_.end()) |
170 tiles_that_need_to_be_rasterized_.erase(raster_iter); | 170 tiles_that_need_to_be_rasterized_.erase(raster_iter); |
171 | 171 |
172 tiles_that_need_to_be_initialized_for_activation_.erase(tile); | 172 tiles_that_need_to_be_initialized_for_activation_.erase(tile); |
| 173 oom_tiles_that_need_to_be_initialized_for_activation_.erase(tile); |
173 | 174 |
174 DCHECK(std::find(tiles_.begin(), tiles_.end(), tile) != tiles_.end()); | 175 DCHECK(std::find(tiles_.begin(), tiles_.end(), tile) != tiles_.end()); |
175 FreeResourcesForTile(tile); | 176 FreeResourcesForTile(tile); |
176 tiles_.erase(std::remove(tiles_.begin(), tiles_.end(), tile)); | 177 tiles_.erase(std::remove(tiles_.begin(), tiles_.end(), tile)); |
177 } | 178 } |
178 | 179 |
179 bool TileManager::ShouldForceTasksRequiredForActivationToComplete() const { | 180 bool TileManager::ShouldForceTasksRequiredForActivationToComplete() const { |
180 return client_->ShouldForceTileUploadsRequiredForActivationToComplete(); | 181 return client_->ShouldForceTileUploadsRequiredForActivationToComplete(); |
181 } | 182 } |
182 | 183 |
| 184 void TileManager::DidFinishedRunningTasks() { |
| 185 // When OOM, keep re-assigning memory until we reach a steady state |
| 186 // where top-priority tiles are initialized. |
| 187 if (!memory_stats_from_last_assign_.bytes_over) |
| 188 return; |
| 189 |
| 190 raster_worker_pool_->CheckForCompletedTasks(); |
| 191 |
| 192 AssignGpuMemoryToTiles(); |
| 193 |
| 194 if (!oom_tiles_that_need_to_be_initialized_for_activation_.empty()) |
| 195 ReassignGpuMemoryToOOMTilesRequiredForActivation(); |
| 196 |
| 197 // |tiles_that_need_to_be_rasterized_| will be empty when we reach a |
| 198 // steady memory state. Keep scheduling tasks until we reach this state. |
| 199 if (!tiles_that_need_to_be_rasterized_.empty()) { |
| 200 ScheduleTasks(); |
| 201 return; |
| 202 } |
| 203 |
| 204 // Use on-demand raster for any tiles that have not been been assigned |
| 205 // memory after reaching a steady memory state. |
| 206 for (TileSet::iterator it = |
| 207 oom_tiles_that_need_to_be_initialized_for_activation_.begin(); |
| 208 it != oom_tiles_that_need_to_be_initialized_for_activation_.end(); |
| 209 ++it) { |
| 210 Tile* tile = *it; |
| 211 ManagedTileState& mts = tile->managed_state(); |
| 212 mts.tile_versions[mts.raster_mode].set_rasterize_on_demand(); |
| 213 } |
| 214 oom_tiles_that_need_to_be_initialized_for_activation_.clear(); |
| 215 |
| 216 client_->NotifyReadyToActivate(); |
| 217 } |
| 218 |
| 219 void TileManager::DidFinishedRunningTasksRequiredForActivation() { |
| 220 // This is only a true indication that all tiles required for |
| 221 // activation are initialized when no tiles are OOM. We need to |
| 222 // wait for DidFinishRunningTasks() to be called, try to re-assign |
| 223 // memory and in worst case use on-demand raster when tiles |
| 224 // required for activation are OOM. |
| 225 if (!oom_tiles_that_need_to_be_initialized_for_activation_.empty()) |
| 226 return; |
| 227 |
| 228 // TODO(reveman): Push the responsibility of calling CheckForCompletedTasks() |
| 229 // to the LTHI where it can be delayed until it's time to draw. |
| 230 raster_worker_pool_->CheckForCompletedTasks(); |
| 231 } |
| 232 |
183 class BinComparator { | 233 class BinComparator { |
184 public: | 234 public: |
185 bool operator() (const Tile* a, const Tile* b) const { | 235 bool operator() (const Tile* a, const Tile* b) const { |
186 const ManagedTileState& ams = a->managed_state(); | 236 const ManagedTileState& ams = a->managed_state(); |
187 const ManagedTileState& bms = b->managed_state(); | 237 const ManagedTileState& bms = b->managed_state(); |
188 if (ams.bin[HIGH_PRIORITY_BIN] != bms.bin[HIGH_PRIORITY_BIN]) | 238 if (ams.bin[HIGH_PRIORITY_BIN] != bms.bin[HIGH_PRIORITY_BIN]) |
189 return ams.bin[HIGH_PRIORITY_BIN] < bms.bin[HIGH_PRIORITY_BIN]; | 239 return ams.bin[HIGH_PRIORITY_BIN] < bms.bin[HIGH_PRIORITY_BIN]; |
190 | 240 |
191 if (ams.bin[LOW_PRIORITY_BIN] != bms.bin[LOW_PRIORITY_BIN]) | 241 if (ams.bin[LOW_PRIORITY_BIN] != bms.bin[LOW_PRIORITY_BIN]) |
192 return ams.bin[LOW_PRIORITY_BIN] < bms.bin[LOW_PRIORITY_BIN]; | 242 return ams.bin[LOW_PRIORITY_BIN] < bms.bin[LOW_PRIORITY_BIN]; |
(...skipping 106 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
299 std::sort(tiles_.begin(), tiles_.end(), BinComparator()); | 349 std::sort(tiles_.begin(), tiles_.end(), BinComparator()); |
300 } | 350 } |
301 | 351 |
302 void TileManager::ManageTiles() { | 352 void TileManager::ManageTiles() { |
303 TRACE_EVENT0("cc", "TileManager::ManageTiles"); | 353 TRACE_EVENT0("cc", "TileManager::ManageTiles"); |
304 AssignBinsToTiles(); | 354 AssignBinsToTiles(); |
305 SortTiles(); | 355 SortTiles(); |
306 AssignGpuMemoryToTiles(); | 356 AssignGpuMemoryToTiles(); |
307 CleanUpUnusedImageDecodeTasks(); | 357 CleanUpUnusedImageDecodeTasks(); |
308 | 358 |
309 // This could have changed after AssignGpuMemoryToTiles. | |
310 if (AreTilesRequiredForActivationReady()) | |
311 client_->NotifyReadyToActivate(); | |
312 | |
313 TRACE_EVENT_INSTANT1( | 359 TRACE_EVENT_INSTANT1( |
314 "cc", "DidManage", TRACE_EVENT_SCOPE_THREAD, | 360 "cc", "DidManage", TRACE_EVENT_SCOPE_THREAD, |
315 "state", TracedValue::FromValue(BasicStateAsValue().release())); | 361 "state", TracedValue::FromValue(BasicStateAsValue().release())); |
316 | 362 |
317 // Finally, schedule rasterizer tasks. | 363 // Finally, schedule rasterizer tasks. |
318 ScheduleTasks(); | 364 ScheduleTasks(); |
319 } | 365 } |
320 | 366 |
321 void TileManager::CheckForCompletedTileUploads() { | 367 void TileManager::CheckForCompletedTileUploads() { |
322 raster_worker_pool_->CheckForCompletedTasks(); | 368 raster_worker_pool_->CheckForCompletedTasks(); |
(...skipping 84 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
407 return raster_mode; | 453 return raster_mode; |
408 } | 454 } |
409 | 455 |
410 void TileManager::AssignGpuMemoryToTiles() { | 456 void TileManager::AssignGpuMemoryToTiles() { |
411 TRACE_EVENT0("cc", "TileManager::AssignGpuMemoryToTiles"); | 457 TRACE_EVENT0("cc", "TileManager::AssignGpuMemoryToTiles"); |
412 | 458 |
413 // Now give memory out to the tiles until we're out, and build | 459 // Now give memory out to the tiles until we're out, and build |
414 // the needs-to-be-rasterized queue. | 460 // the needs-to-be-rasterized queue. |
415 tiles_that_need_to_be_rasterized_.clear(); | 461 tiles_that_need_to_be_rasterized_.clear(); |
416 tiles_that_need_to_be_initialized_for_activation_.clear(); | 462 tiles_that_need_to_be_initialized_for_activation_.clear(); |
| 463 oom_tiles_that_need_to_be_initialized_for_activation_.clear(); |
417 | 464 |
418 size_t bytes_releasable = 0; | 465 size_t bytes_releasable = 0; |
419 for (TileVector::const_iterator it = tiles_.begin(); | 466 for (TileVector::const_iterator it = tiles_.begin(); |
420 it != tiles_.end(); | 467 it != tiles_.end(); |
421 ++it) { | 468 ++it) { |
422 const Tile* tile = *it; | 469 const Tile* tile = *it; |
423 const ManagedTileState& mts = tile->managed_state(); | 470 const ManagedTileState& mts = tile->managed_state(); |
424 for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) { | 471 for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) { |
425 if (mts.tile_versions[mode].resource_) | 472 if (mts.tile_versions[mode].resource_) |
426 bytes_releasable += tile->bytes_consumed_if_allocated(); | 473 bytes_releasable += tile->bytes_consumed_if_allocated(); |
427 } | 474 } |
428 } | 475 } |
429 | 476 |
430 // Cast to prevent overflow. | 477 // Cast to prevent overflow. |
431 int64 bytes_available = | 478 int64 bytes_available = |
432 static_cast<int64>(bytes_releasable) + | 479 static_cast<int64>(bytes_releasable) + |
433 static_cast<int64>(global_state_.memory_limit_in_bytes) - | 480 static_cast<int64>(global_state_.memory_limit_in_bytes) - |
434 static_cast<int64>(resource_pool_->acquired_memory_usage_bytes()); | 481 static_cast<int64>(resource_pool_->acquired_memory_usage_bytes()); |
435 | 482 |
436 size_t bytes_allocatable = | 483 size_t bytes_allocatable = |
437 std::max(static_cast<int64>(0), bytes_available); | 484 std::max(static_cast<int64>(0), bytes_available); |
438 | 485 |
439 size_t bytes_that_exceeded_memory_budget_in_now_bin = 0; | 486 size_t bytes_that_exceeded_memory_budget = 0; |
440 size_t bytes_left = bytes_allocatable; | 487 size_t bytes_left = bytes_allocatable; |
441 size_t bytes_oom_in_now_bin_on_pending_tree = 0; | |
442 TileVector tiles_requiring_memory_but_oomed; | |
443 bool higher_priority_tile_oomed = false; | 488 bool higher_priority_tile_oomed = false; |
444 for (TileVector::iterator it = tiles_.begin(); | 489 for (TileVector::iterator it = tiles_.begin(); |
445 it != tiles_.end(); | 490 it != tiles_.end(); |
446 ++it) { | 491 ++it) { |
447 Tile* tile = *it; | 492 Tile* tile = *it; |
448 ManagedTileState& mts = tile->managed_state(); | 493 ManagedTileState& mts = tile->managed_state(); |
449 | 494 |
450 // Pick the better version out of the one we already set, | 495 // Pick the better version out of the one we already set, |
451 // and the one that is required. | 496 // and the one that is required. |
452 mts.raster_mode = std::min(mts.raster_mode, DetermineRasterMode(tile)); | 497 mts.raster_mode = std::min(mts.raster_mode, DetermineRasterMode(tile)); |
(...skipping 19 matching lines...) Expand all Loading... |
472 tile_bytes += tile->bytes_consumed_if_allocated(); | 517 tile_bytes += tile->bytes_consumed_if_allocated(); |
473 } | 518 } |
474 | 519 |
475 // If we don't have the required version, and it's not in flight | 520 // If we don't have the required version, and it's not in flight |
476 // then we'll have to pay to create a new task. | 521 // then we'll have to pay to create a new task. |
477 if (!tile_version.resource_ && tile_version.raster_task_.is_null()) | 522 if (!tile_version.resource_ && tile_version.raster_task_.is_null()) |
478 tile_bytes += tile->bytes_consumed_if_allocated(); | 523 tile_bytes += tile->bytes_consumed_if_allocated(); |
479 | 524 |
480 // Tile is OOM. | 525 // Tile is OOM. |
481 if (tile_bytes > bytes_left) { | 526 if (tile_bytes > bytes_left) { |
482 mts.tile_versions[mts.raster_mode].set_rasterize_on_demand(); | 527 if (tile->required_for_activation()) |
483 if (mts.tree_bin[PENDING_TREE] == NOW_BIN) { | 528 oom_tiles_that_need_to_be_initialized_for_activation_.insert(tile); |
484 tiles_requiring_memory_but_oomed.push_back(tile); | |
485 bytes_oom_in_now_bin_on_pending_tree += tile_bytes; | |
486 } | |
487 FreeResourcesForTile(tile); | 529 FreeResourcesForTile(tile); |
488 higher_priority_tile_oomed = true; | 530 higher_priority_tile_oomed = true; |
| 531 bytes_that_exceeded_memory_budget += tile_bytes; |
489 continue; | 532 continue; |
490 } | 533 } |
491 | 534 |
492 tile_version.set_use_resource(); | 535 tile_version.set_use_resource(); |
493 bytes_left -= tile_bytes; | 536 bytes_left -= tile_bytes; |
494 | 537 |
495 // Tile shouldn't be rasterized if we've failed to assign | 538 // Tile shouldn't be rasterized if we've failed to assign |
496 // gpu memory to a higher priority tile. This is important for | 539 // gpu memory to a higher priority tile. This is important for |
497 // two reasons: | 540 // two reasons: |
498 // 1. Tile size should not impact raster priority. | 541 // 1. Tile size should not impact raster priority. |
499 // 2. Tile with unreleasable memory could otherwise incorrectly | 542 // 2. Tile with unreleasable memory could otherwise incorrectly |
500 // be added as it's not affected by |bytes_allocatable|. | 543 // be added as it's not affected by |bytes_allocatable|. |
501 if (higher_priority_tile_oomed) | 544 if (higher_priority_tile_oomed) |
502 continue; | 545 continue; |
503 | 546 |
504 if (!tile_version.resource_) | 547 if (!tile_version.resource_) |
505 tiles_that_need_to_be_rasterized_.push_back(tile); | 548 tiles_that_need_to_be_rasterized_.push_back(tile); |
506 | 549 |
507 if (!tile->IsReadyToDraw(NULL) && | 550 if (!tile->IsReadyToDraw(NULL) && |
508 tile->required_for_activation()) { | 551 tile->required_for_activation()) { |
509 AddRequiredTileForActivation(tile); | 552 AddRequiredTileForActivation(tile); |
510 } | 553 } |
511 } | 554 } |
512 | 555 |
513 // In OOM situation, we iterate tiles_, remove the memory for active tree | 556 ever_exceeded_memory_budget_ |= bytes_that_exceeded_memory_budget > 0; |
514 // and not the now bin. And give them to bytes_oom_in_now_bin_on_pending_tree | |
515 if (!tiles_requiring_memory_but_oomed.empty()) { | |
516 size_t bytes_freed = 0; | |
517 for (TileVector::iterator it = tiles_.begin(); it != tiles_.end(); ++it) { | |
518 Tile* tile = *it; | |
519 ManagedTileState& mts = tile->managed_state(); | |
520 ManagedTileState::TileVersion& tile_version = | |
521 mts.tile_versions[mts.raster_mode]; | |
522 if (mts.tree_bin[PENDING_TREE] == NEVER_BIN && | |
523 mts.tree_bin[ACTIVE_TREE] != NOW_BIN) { | |
524 size_t bytes_that_can_be_freed = 0; | |
525 | |
526 // If the tile is in the to-rasterize list, but it has no task, | |
527 // then it means that we have assigned memory for it. | |
528 TileVector::iterator raster_it = | |
529 std::find(tiles_that_need_to_be_rasterized_.begin(), | |
530 tiles_that_need_to_be_rasterized_.end(), | |
531 tile); | |
532 if (raster_it != tiles_that_need_to_be_rasterized_.end() && | |
533 tile_version.raster_task_.is_null()) { | |
534 bytes_that_can_be_freed += tile->bytes_consumed_if_allocated(); | |
535 } | |
536 | |
537 // Also consider all of the completed resources for freeing. | |
538 for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) { | |
539 ManagedTileState::TileVersion& tile_version = | |
540 mts.tile_versions[mode]; | |
541 if (tile_version.resource_) { | |
542 DCHECK(!tile->required_for_activation()); | |
543 bytes_that_can_be_freed += tile->bytes_consumed_if_allocated(); | |
544 } | |
545 } | |
546 | |
547 // If we can free anything, then do so. | |
548 if (bytes_that_can_be_freed > 0) { | |
549 FreeResourcesForTile(tile); | |
550 bytes_freed += bytes_that_can_be_freed; | |
551 mts.tile_versions[mts.raster_mode].set_rasterize_on_demand(); | |
552 if (raster_it != tiles_that_need_to_be_rasterized_.end()) | |
553 tiles_that_need_to_be_rasterized_.erase(raster_it); | |
554 } | |
555 } | |
556 | |
557 if (bytes_oom_in_now_bin_on_pending_tree <= bytes_freed) | |
558 break; | |
559 } | |
560 | |
561 for (TileVector::iterator it = tiles_requiring_memory_but_oomed.begin(); | |
562 it != tiles_requiring_memory_but_oomed.end() && bytes_freed > 0; | |
563 ++it) { | |
564 Tile* tile = *it; | |
565 ManagedTileState& mts = tile->managed_state(); | |
566 size_t bytes_needed = tile->bytes_consumed_if_allocated(); | |
567 if (bytes_needed > bytes_freed) | |
568 continue; | |
569 mts.tile_versions[mts.raster_mode].set_use_resource(); | |
570 bytes_freed -= bytes_needed; | |
571 tiles_that_need_to_be_rasterized_.push_back(tile); | |
572 if (tile->required_for_activation()) | |
573 AddRequiredTileForActivation(tile); | |
574 } | |
575 } | |
576 | |
577 ever_exceeded_memory_budget_ |= | |
578 bytes_that_exceeded_memory_budget_in_now_bin > 0; | |
579 if (ever_exceeded_memory_budget_) { | 557 if (ever_exceeded_memory_budget_) { |
580 TRACE_COUNTER_ID2("cc", "over_memory_budget", this, | 558 TRACE_COUNTER_ID2("cc", "over_memory_budget", this, |
581 "budget", global_state_.memory_limit_in_bytes, | 559 "budget", global_state_.memory_limit_in_bytes, |
582 "over", bytes_that_exceeded_memory_budget_in_now_bin); | 560 "over", bytes_that_exceeded_memory_budget); |
583 } | 561 } |
584 memory_stats_from_last_assign_.total_budget_in_bytes = | 562 memory_stats_from_last_assign_.total_budget_in_bytes = |
585 global_state_.memory_limit_in_bytes; | 563 global_state_.memory_limit_in_bytes; |
586 memory_stats_from_last_assign_.bytes_allocated = | 564 memory_stats_from_last_assign_.bytes_allocated = |
587 bytes_allocatable - bytes_left; | 565 bytes_allocatable - bytes_left; |
588 memory_stats_from_last_assign_.bytes_unreleasable = | 566 memory_stats_from_last_assign_.bytes_unreleasable = |
589 bytes_allocatable - bytes_releasable; | 567 bytes_allocatable - bytes_releasable; |
590 memory_stats_from_last_assign_.bytes_over = | 568 memory_stats_from_last_assign_.bytes_over = |
591 bytes_that_exceeded_memory_budget_in_now_bin; | 569 bytes_that_exceeded_memory_budget; |
| 570 } |
| 571 |
| 572 void TileManager::ReassignGpuMemoryToOOMTilesRequiredForActivation() { |
| 573 TRACE_EVENT0( |
| 574 "cc", "TileManager::ReassignGpuMemoryToOOMTilesRequiredForActivation"); |
| 575 |
| 576 size_t bytes_oom_for_required_tiles = 0; |
| 577 TileVector tiles_requiring_memory_but_oomed; |
| 578 for (TileVector::iterator it = tiles_.begin(); it != tiles_.end(); ++it) { |
| 579 Tile* tile = *it; |
| 580 if (oom_tiles_that_need_to_be_initialized_for_activation_.find(tile) == |
| 581 oom_tiles_that_need_to_be_initialized_for_activation_.end()) |
| 582 continue; |
| 583 |
| 584 tiles_requiring_memory_but_oomed.push_back(tile); |
| 585 bytes_oom_for_required_tiles += tile->bytes_consumed_if_allocated(); |
| 586 } |
| 587 |
| 588 if (tiles_requiring_memory_but_oomed.empty()) |
| 589 return; |
| 590 |
| 591 // In OOM situation, we iterate tiles_, remove the memory for active tree |
| 592 // and not the now bin. And give them to bytes_oom_for_required_tiles |
| 593 size_t bytes_freed = 0; |
| 594 for (TileVector::reverse_iterator it = tiles_.rbegin(); |
| 595 it != tiles_.rend(); ++it) { |
| 596 Tile* tile = *it; |
| 597 ManagedTileState& mts = tile->managed_state(); |
| 598 if (mts.tree_bin[PENDING_TREE] == NEVER_BIN && |
| 599 mts.tree_bin[ACTIVE_TREE] != NOW_BIN) { |
| 600 ManagedTileState::TileVersion& tile_version = |
| 601 mts.tile_versions[mts.raster_mode]; |
| 602 |
| 603 // If the tile is in the to-rasterize list, but it has no task, |
| 604 // then it means that we have assigned memory for it. |
| 605 TileVector::iterator raster_it = |
| 606 std::find(tiles_that_need_to_be_rasterized_.begin(), |
| 607 tiles_that_need_to_be_rasterized_.end(), |
| 608 tile); |
| 609 if (raster_it != tiles_that_need_to_be_rasterized_.end() && |
| 610 tile_version.raster_task_.is_null()) { |
| 611 bytes_freed += tile->bytes_consumed_if_allocated(); |
| 612 tiles_that_need_to_be_rasterized_.erase(raster_it); |
| 613 } |
| 614 |
| 615 // Also consider all of the completed resources for freeing. |
| 616 for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) { |
| 617 if (mts.tile_versions[mode].resource_) { |
| 618 DCHECK(!tile->required_for_activation()); |
| 619 FreeResourceForTile(tile, static_cast<RasterMode>(mode)); |
| 620 bytes_freed += tile->bytes_consumed_if_allocated(); |
| 621 } |
| 622 } |
| 623 } |
| 624 |
| 625 if (bytes_oom_for_required_tiles <= bytes_freed) |
| 626 break; |
| 627 } |
| 628 |
| 629 for (TileVector::iterator it = tiles_requiring_memory_but_oomed.begin(); |
| 630 it != tiles_requiring_memory_but_oomed.end() && bytes_freed > 0; |
| 631 ++it) { |
| 632 Tile* tile = *it; |
| 633 ManagedTileState& mts = tile->managed_state(); |
| 634 size_t bytes_needed = tile->bytes_consumed_if_allocated(); |
| 635 if (bytes_needed > bytes_freed) |
| 636 continue; |
| 637 mts.tile_versions[mts.raster_mode].set_use_resource(); |
| 638 bytes_freed -= bytes_needed; |
| 639 tiles_that_need_to_be_rasterized_.push_back(tile); |
| 640 DCHECK(tile->required_for_activation()); |
| 641 AddRequiredTileForActivation(tile); |
| 642 oom_tiles_that_need_to_be_initialized_for_activation_.erase(tile); |
| 643 } |
592 } | 644 } |
593 | 645 |
594 void TileManager::CleanUpUnusedImageDecodeTasks() { | 646 void TileManager::CleanUpUnusedImageDecodeTasks() { |
595 // Calculate a set of layers that are used by at least one tile. | 647 // Calculate a set of layers that are used by at least one tile. |
596 base::hash_set<int> used_layers; | 648 base::hash_set<int> used_layers; |
597 for (TileVector::iterator it = tiles_.begin(); it != tiles_.end(); ++it) | 649 for (TileVector::iterator it = tiles_.begin(); it != tiles_.end(); ++it) |
598 used_layers.insert((*it)->layer_id()); | 650 used_layers.insert((*it)->layer_id()); |
599 | 651 |
600 // Now calculate the set of layers in |image_decode_tasks_| that are not used | 652 // Now calculate the set of layers in |image_decode_tasks_| that are not used |
601 // by any tile. | 653 // by any tile. |
(...skipping 30 matching lines...) Expand all Loading... |
632 void TileManager::FreeUnusedResourcesForTile(Tile* tile) { | 684 void TileManager::FreeUnusedResourcesForTile(Tile* tile) { |
633 RasterMode used_mode = HIGH_QUALITY_RASTER_MODE; | 685 RasterMode used_mode = HIGH_QUALITY_RASTER_MODE; |
634 bool version_is_used = tile->IsReadyToDraw(&used_mode); | 686 bool version_is_used = tile->IsReadyToDraw(&used_mode); |
635 for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) { | 687 for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) { |
636 if (!version_is_used || mode != used_mode) | 688 if (!version_is_used || mode != used_mode) |
637 FreeResourceForTile(tile, static_cast<RasterMode>(mode)); | 689 FreeResourceForTile(tile, static_cast<RasterMode>(mode)); |
638 } | 690 } |
639 } | 691 } |
640 | 692 |
641 void TileManager::ScheduleTasks() { | 693 void TileManager::ScheduleTasks() { |
642 TRACE_EVENT0("cc", "TileManager::ScheduleTasks"); | 694 TRACE_EVENT1("cc", "TileManager::ScheduleTasks", |
| 695 "count", tiles_that_need_to_be_rasterized_.size()); |
643 RasterWorkerPool::RasterTask::Queue tasks; | 696 RasterWorkerPool::RasterTask::Queue tasks; |
644 | 697 |
645 // Build a new task queue containing all task currently needed. Tasks | 698 // Build a new task queue containing all task currently needed. Tasks |
646 // are added in order of priority, highest priority task first. | 699 // are added in order of priority, highest priority task first. |
647 for (TileVector::iterator it = tiles_that_need_to_be_rasterized_.begin(); | 700 for (TileVector::iterator it = tiles_that_need_to_be_rasterized_.begin(); |
648 it != tiles_that_need_to_be_rasterized_.end(); | 701 it != tiles_that_need_to_be_rasterized_.end(); |
649 ++it) { | 702 ++it) { |
650 Tile* tile = *it; | 703 Tile* tile = *it; |
651 ManagedTileState& mts = tile->managed_state(); | 704 ManagedTileState& mts = tile->managed_state(); |
652 ManagedTileState::TileVersion& tile_version = | 705 ManagedTileState::TileVersion& tile_version = |
653 mts.tile_versions[mts.raster_mode]; | 706 mts.tile_versions[mts.raster_mode]; |
654 | 707 |
655 DCHECK(tile_version.requires_resource()); | 708 DCHECK(tile_version.requires_resource()); |
656 DCHECK(!tile_version.resource_); | 709 DCHECK(!tile_version.resource_); |
657 | 710 |
658 if (tile_version.raster_task_.is_null()) | 711 if (tile_version.raster_task_.is_null()) |
659 tile_version.raster_task_ = CreateRasterTask(tile); | 712 tile_version.raster_task_ = CreateRasterTask(tile); |
660 | 713 |
661 tasks.Append(tile_version.raster_task_, tile->required_for_activation()); | 714 tasks.Append(tile_version.raster_task_, tile->required_for_activation()); |
662 } | 715 } |
663 | 716 |
664 // Schedule running of |tasks|. This replaces any previously | 717 // Schedule running of |tasks|. This replaces any previously |
665 // scheduled tasks and effectively cancels all tasks not present | 718 // scheduled tasks and effectively cancels all tasks not present |
666 // in |tasks|. | 719 // in |tasks|. |
667 raster_worker_pool_->ScheduleTasks(&tasks); | 720 raster_worker_pool_->ScheduleTasks(&tasks); |
668 } | 721 } |
669 | 722 |
670 RasterWorkerPool::Task TileManager::CreateImageDecodeTask( | 723 RasterWorkerPool::Task TileManager::CreateImageDecodeTask( |
671 Tile* tile, skia::LazyPixelRef* pixel_ref) { | 724 Tile* tile, skia::LazyPixelRef* pixel_ref) { |
672 TRACE_EVENT0("cc", "TileManager::CreateImageDecodeTask"); | |
673 | |
674 return RasterWorkerPool::CreateImageDecodeTask( | 725 return RasterWorkerPool::CreateImageDecodeTask( |
675 pixel_ref, | 726 pixel_ref, |
676 tile->layer_id(), | 727 tile->layer_id(), |
677 rendering_stats_instrumentation_, | 728 rendering_stats_instrumentation_, |
678 base::Bind(&TileManager::OnImageDecodeTaskCompleted, | 729 base::Bind(&TileManager::OnImageDecodeTaskCompleted, |
679 base::Unretained(this), | 730 base::Unretained(this), |
680 tile->layer_id(), | 731 tile->layer_id(), |
681 base::Unretained(pixel_ref))); | 732 base::Unretained(pixel_ref))); |
682 } | 733 } |
683 | 734 |
684 RasterTaskMetadata TileManager::GetRasterTaskMetadata( | 735 RasterTaskMetadata TileManager::GetRasterTaskMetadata( |
685 const Tile& tile) const { | 736 const Tile& tile) const { |
686 RasterTaskMetadata metadata; | 737 RasterTaskMetadata metadata; |
687 const ManagedTileState& mts = tile.managed_state(); | 738 const ManagedTileState& mts = tile.managed_state(); |
688 metadata.is_tile_in_pending_tree_now_bin = | 739 metadata.is_tile_in_pending_tree_now_bin = |
689 mts.tree_bin[PENDING_TREE] == NOW_BIN; | 740 mts.tree_bin[PENDING_TREE] == NOW_BIN; |
690 metadata.tile_resolution = mts.resolution; | 741 metadata.tile_resolution = mts.resolution; |
691 metadata.layer_id = tile.layer_id(); | 742 metadata.layer_id = tile.layer_id(); |
692 metadata.tile_id = &tile; | 743 metadata.tile_id = &tile; |
693 metadata.source_frame_number = tile.source_frame_number(); | 744 metadata.source_frame_number = tile.source_frame_number(); |
694 return metadata; | 745 return metadata; |
695 } | 746 } |
696 | 747 |
697 RasterWorkerPool::RasterTask TileManager::CreateRasterTask(Tile* tile) { | 748 RasterWorkerPool::RasterTask TileManager::CreateRasterTask(Tile* tile) { |
698 TRACE_EVENT0("cc", "TileManager::CreateRasterTask"); | |
699 | |
700 ManagedTileState& mts = tile->managed_state(); | 749 ManagedTileState& mts = tile->managed_state(); |
701 | 750 |
702 scoped_ptr<ResourcePool::Resource> resource = | 751 scoped_ptr<ResourcePool::Resource> resource = |
703 resource_pool_->AcquireResource(tile->tile_size_.size(), | 752 resource_pool_->AcquireResource(tile->tile_size_.size(), |
704 texture_format_); | 753 texture_format_); |
705 const Resource* const_resource = resource.get(); | 754 const Resource* const_resource = resource.get(); |
706 | 755 |
707 // Create and queue all image decode tasks that this tile depends on. | 756 // Create and queue all image decode tasks that this tile depends on. |
708 RasterWorkerPool::Task::Set decode_tasks; | 757 RasterWorkerPool::Task::Set decode_tasks; |
709 PixelRefTaskMap& existing_pixel_refs = image_decode_tasks_[tile->layer_id()]; | 758 PixelRefTaskMap& existing_pixel_refs = image_decode_tasks_[tile->layer_id()]; |
(...skipping 107 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
817 } | 866 } |
818 | 867 |
819 void TileManager::DidTileTreeBinChange(Tile* tile, | 868 void TileManager::DidTileTreeBinChange(Tile* tile, |
820 TileManagerBin new_tree_bin, | 869 TileManagerBin new_tree_bin, |
821 WhichTree tree) { | 870 WhichTree tree) { |
822 ManagedTileState& mts = tile->managed_state(); | 871 ManagedTileState& mts = tile->managed_state(); |
823 mts.tree_bin[tree] = new_tree_bin; | 872 mts.tree_bin[tree] = new_tree_bin; |
824 } | 873 } |
825 | 874 |
826 } // namespace cc | 875 } // namespace cc |
OLD | NEW |