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 209 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
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 Loading... | |
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), | 268 bytes_releasable_(0), |
377 resources_releasable_(0), | 269 resources_releasable_(0), |
270 bytes_required_but_not_allocated_(0), | |
378 ever_exceeded_memory_budget_(false), | 271 ever_exceeded_memory_budget_(false), |
379 rendering_stats_instrumentation_(rendering_stats_instrumentation), | 272 rendering_stats_instrumentation_(rendering_stats_instrumentation), |
380 did_initialize_visible_tile_(false), | 273 did_initialize_visible_tile_(false), |
381 did_check_for_completed_tasks_since_last_schedule_tasks_(true), | 274 did_check_for_completed_tasks_since_last_schedule_tasks_(true), |
382 ready_to_activate_check_notifier_( | 275 ready_to_activate_check_notifier_( |
383 task_runner_, | 276 task_runner_, |
384 base::Bind(&TileManager::CheckIfReadyToActivate, | 277 base::Bind(&TileManager::CheckIfReadyToActivate, |
385 base::Unretained(this))) { | 278 base::Unretained(this))) { |
386 rasterizer_->SetClient(this); | 279 rasterizer_->SetClient(this); |
387 } | 280 } |
(...skipping 13 matching lines...) Expand all Loading... | |
401 // This should finish all pending tasks and release any uninitialized | 294 // This should finish all pending tasks and release any uninitialized |
402 // resources. | 295 // resources. |
403 rasterizer_->Shutdown(); | 296 rasterizer_->Shutdown(); |
404 rasterizer_->CheckForCompletedTasks(); | 297 rasterizer_->CheckForCompletedTasks(); |
405 | 298 |
406 DCHECK_EQ(0u, bytes_releasable_); | 299 DCHECK_EQ(0u, bytes_releasable_); |
407 DCHECK_EQ(0u, resources_releasable_); | 300 DCHECK_EQ(0u, resources_releasable_); |
408 } | 301 } |
409 | 302 |
410 void TileManager::Release(Tile* tile) { | 303 void TileManager::Release(Tile* tile) { |
411 prioritized_tiles_dirty_ = true; | |
412 released_tiles_.push_back(tile); | 304 released_tiles_.push_back(tile); |
413 } | 305 } |
414 | 306 |
415 void TileManager::DidChangeTilePriority(Tile* tile) { | |
416 prioritized_tiles_dirty_ = true; | |
417 } | |
418 | |
419 bool TileManager::ShouldForceTasksRequiredForActivationToComplete() const { | 307 bool TileManager::ShouldForceTasksRequiredForActivationToComplete() const { |
420 return global_state_.tree_priority != SMOOTHNESS_TAKES_PRIORITY; | 308 return global_state_.tree_priority != SMOOTHNESS_TAKES_PRIORITY; |
421 } | 309 } |
422 | 310 |
423 void TileManager::CleanUpReleasedTiles() { | 311 void TileManager::CleanUpReleasedTiles() { |
424 for (std::vector<Tile*>::iterator it = released_tiles_.begin(); | 312 for (std::vector<Tile*>::iterator it = released_tiles_.begin(); |
425 it != released_tiles_.end(); | 313 it != released_tiles_.end(); |
426 ++it) { | 314 ++it) { |
427 Tile* tile = *it; | 315 Tile* tile = *it; |
428 ManagedTileState& mts = tile->managed_state(); | 316 ManagedTileState& mts = tile->managed_state(); |
(...skipping 13 matching lines...) Expand all Loading... | |
442 used_layer_counts_.erase(layer_it); | 330 used_layer_counts_.erase(layer_it); |
443 image_decode_tasks_.erase(tile->layer_id()); | 331 image_decode_tasks_.erase(tile->layer_id()); |
444 } | 332 } |
445 | 333 |
446 delete tile; | 334 delete tile; |
447 } | 335 } |
448 | 336 |
449 released_tiles_.clear(); | 337 released_tiles_.clear(); |
450 } | 338 } |
451 | 339 |
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() { | 340 void TileManager::DidFinishRunningTasks() { |
464 TRACE_EVENT0("cc", "TileManager::DidFinishRunningTasks"); | 341 TRACE_EVENT0("cc", "TileManager::DidFinishRunningTasks"); |
465 | 342 |
466 bool memory_usage_above_limit = resource_pool_->total_memory_usage_bytes() > | 343 bool memory_usage_above_limit = resource_pool_->total_memory_usage_bytes() > |
467 global_state_.soft_memory_limit_in_bytes; | 344 global_state_.soft_memory_limit_in_bytes; |
468 | 345 |
469 // When OOM, keep re-assigning memory until we reach a steady state | 346 // When OOM, keep re-assigning memory until we reach a steady state |
470 // where top-priority tiles are initialized. | 347 // where top-priority tiles are initialized. |
471 if (all_tiles_that_need_to_be_rasterized_have_memory_ && | 348 if (all_tiles_that_need_to_be_rasterized_have_memory_ && |
472 !memory_usage_above_limit) | 349 !memory_usage_above_limit) |
473 return; | 350 return; |
474 | 351 |
475 rasterizer_->CheckForCompletedTasks(); | 352 rasterizer_->CheckForCompletedTasks(); |
476 did_check_for_completed_tasks_since_last_schedule_tasks_ = true; | 353 did_check_for_completed_tasks_since_last_schedule_tasks_ = true; |
477 | 354 |
478 TileVector tiles_that_need_to_be_rasterized; | 355 TileVector tiles_that_need_to_be_rasterized; |
479 AssignGpuMemoryToTiles(&prioritized_tiles_, | 356 AssignGpuMemoryToTiles(&tiles_that_need_to_be_rasterized); |
480 &tiles_that_need_to_be_rasterized); | |
481 | 357 |
482 // |tiles_that_need_to_be_rasterized| will be empty when we reach a | 358 // |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. | 359 // steady memory state. Keep scheduling tasks until we reach this state. |
484 if (!tiles_that_need_to_be_rasterized.empty()) { | 360 if (!tiles_that_need_to_be_rasterized.empty()) { |
485 ScheduleTasks(tiles_that_need_to_be_rasterized); | 361 ScheduleTasks(tiles_that_need_to_be_rasterized); |
486 return; | 362 return; |
487 } | 363 } |
488 | 364 |
489 resource_pool_->ReduceResourceUsage(); | 365 resource_pool_->ReduceResourceUsage(); |
490 | 366 |
(...skipping 20 matching lines...) Expand all Loading... | |
511 tile_version.set_rasterize_on_demand(); | 387 tile_version.set_rasterize_on_demand(); |
512 client_->NotifyTileStateChanged(tile); | 388 client_->NotifyTileStateChanged(tile); |
513 } | 389 } |
514 } | 390 } |
515 | 391 |
516 DCHECK(IsReadyToActivate()); | 392 DCHECK(IsReadyToActivate()); |
517 ready_to_activate_check_notifier_.Schedule(); | 393 ready_to_activate_check_notifier_.Schedule(); |
518 } | 394 } |
519 | 395 |
520 void TileManager::DidFinishRunningTasksRequiredForActivation() { | 396 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(); | 397 ready_to_activate_check_notifier_.Schedule(); |
530 } | 398 } |
531 | 399 |
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) { | 400 void TileManager::ManageTiles(const GlobalStateThatImpactsTilePriority& state) { |
658 TRACE_EVENT0("cc", "TileManager::ManageTiles"); | 401 TRACE_EVENT0("cc", "TileManager::ManageTiles"); |
659 | 402 |
660 // Update internal state. | 403 // Update internal state. |
661 if (state != global_state_) { | 404 global_state_ = state; |
662 global_state_ = state; | 405 |
663 prioritized_tiles_dirty_ = true; | 406 // TODO(vmpstr): See if we still need to keep tiles alive when layers release |
664 } | 407 // them. |
408 CleanUpReleasedTiles(); | |
665 | 409 |
666 // We need to call CheckForCompletedTasks() once in-between each call | 410 // We need to call CheckForCompletedTasks() once in-between each call |
667 // to ScheduleTasks() to prevent canceled tasks from being scheduled. | 411 // to ScheduleTasks() to prevent canceled tasks from being scheduled. |
668 if (!did_check_for_completed_tasks_since_last_schedule_tasks_) { | 412 if (!did_check_for_completed_tasks_since_last_schedule_tasks_) { |
669 rasterizer_->CheckForCompletedTasks(); | 413 rasterizer_->CheckForCompletedTasks(); |
670 did_check_for_completed_tasks_since_last_schedule_tasks_ = true; | 414 did_check_for_completed_tasks_since_last_schedule_tasks_ = true; |
671 } | 415 } |
672 | 416 |
673 UpdatePrioritizedTileSetIfNeeded(); | |
674 | |
675 TileVector tiles_that_need_to_be_rasterized; | 417 TileVector tiles_that_need_to_be_rasterized; |
676 AssignGpuMemoryToTiles(&prioritized_tiles_, | 418 AssignGpuMemoryToTiles(&tiles_that_need_to_be_rasterized); |
677 &tiles_that_need_to_be_rasterized); | |
678 | 419 |
679 // Finally, schedule rasterizer tasks. | 420 // Finally, schedule rasterizer tasks. |
680 ScheduleTasks(tiles_that_need_to_be_rasterized); | 421 ScheduleTasks(tiles_that_need_to_be_rasterized); |
681 | 422 |
682 TRACE_EVENT_INSTANT1("cc", | 423 TRACE_EVENT_INSTANT1("cc", |
683 "DidManage", | 424 "DidManage", |
684 TRACE_EVENT_SCOPE_THREAD, | 425 TRACE_EVENT_SCOPE_THREAD, |
685 "state", | 426 "state", |
686 TracedValue::FromValue(BasicStateAsValue().release())); | 427 TracedValue::FromValue(BasicStateAsValue().release())); |
687 | 428 |
(...skipping 21 matching lines...) Expand all Loading... | |
709 | 450 |
710 bool did_initialize_visible_tile = did_initialize_visible_tile_; | 451 bool did_initialize_visible_tile = did_initialize_visible_tile_; |
711 did_initialize_visible_tile_ = false; | 452 did_initialize_visible_tile_ = false; |
712 return did_initialize_visible_tile; | 453 return did_initialize_visible_tile; |
713 } | 454 } |
714 | 455 |
715 void TileManager::GetMemoryStats(size_t* memory_required_bytes, | 456 void TileManager::GetMemoryStats(size_t* memory_required_bytes, |
716 size_t* memory_nice_to_have_bytes, | 457 size_t* memory_nice_to_have_bytes, |
717 size_t* memory_allocated_bytes, | 458 size_t* memory_allocated_bytes, |
718 size_t* memory_used_bytes) const { | 459 size_t* memory_used_bytes) const { |
719 *memory_required_bytes = memory_required_bytes_; | 460 *memory_required_bytes = resource_pool_->total_memory_usage_bytes() + |
720 *memory_nice_to_have_bytes = memory_nice_to_have_bytes_; | 461 bytes_required_but_not_allocated_; |
462 *memory_nice_to_have_bytes = resource_pool_->total_memory_usage_bytes() + | |
463 bytes_required_but_not_allocated_; | |
721 *memory_allocated_bytes = resource_pool_->total_memory_usage_bytes(); | 464 *memory_allocated_bytes = resource_pool_->total_memory_usage_bytes(); |
722 *memory_used_bytes = resource_pool_->acquired_memory_usage_bytes(); | 465 *memory_used_bytes = resource_pool_->acquired_memory_usage_bytes(); |
723 } | 466 } |
724 | 467 |
725 scoped_ptr<base::Value> TileManager::BasicStateAsValue() const { | 468 scoped_ptr<base::Value> TileManager::BasicStateAsValue() const { |
726 scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue()); | 469 scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue()); |
727 state->SetInteger("tile_count", tiles_.size()); | 470 state->SetInteger("tile_count", tiles_.size()); |
728 state->Set("global_state", global_state_.AsValue().release()); | 471 state->Set("global_state", global_state_.AsValue().release()); |
729 state->Set("memory_requirements", GetMemoryRequirementsAsValue().release()); | 472 state->Set("memory_requirements", GetMemoryRequirementsAsValue().release()); |
730 return state.PassAs<base::Value>(); | 473 return state.PassAs<base::Value>(); |
(...skipping 19 matching lines...) Expand all Loading... | |
750 &memory_allocated_bytes, | 493 &memory_allocated_bytes, |
751 &memory_used_bytes); | 494 &memory_used_bytes); |
752 requirements->SetInteger("memory_required_bytes", memory_required_bytes); | 495 requirements->SetInteger("memory_required_bytes", memory_required_bytes); |
753 requirements->SetInteger("memory_nice_to_have_bytes", | 496 requirements->SetInteger("memory_nice_to_have_bytes", |
754 memory_nice_to_have_bytes); | 497 memory_nice_to_have_bytes); |
755 requirements->SetInteger("memory_allocated_bytes", memory_allocated_bytes); | 498 requirements->SetInteger("memory_allocated_bytes", memory_allocated_bytes); |
756 requirements->SetInteger("memory_used_bytes", memory_used_bytes); | 499 requirements->SetInteger("memory_used_bytes", memory_used_bytes); |
757 return requirements.PassAs<base::Value>(); | 500 return requirements.PassAs<base::Value>(); |
758 } | 501 } |
759 | 502 |
503 bool TileManager::FreeTileResourcesUntilUsageIsWithinLimit( | |
504 EvictionTileIterator* iterator, | |
505 const MemoryUsage& limit, | |
506 MemoryUsage* usage) { | |
507 while (usage->Exceeds(limit)) { | |
508 if (!*iterator) | |
509 return false; | |
510 | |
511 Tile* tile = **iterator; | |
512 *usage -= MemoryUsage::FromTile(tile); | |
513 | |
514 FreeResourcesForTileAndNotifyClientIfTileWasReadyToDraw(tile); | |
515 ++(*iterator); | |
516 } | |
517 return true; | |
518 } | |
519 | |
520 bool TileManager::FreeTileResourcesWithLowerPriorityUntilUsageIsWithinLimit( | |
521 EvictionTileIterator* iterator, | |
522 const MemoryUsage& limit, | |
523 const TilePriority& max_priority, | |
524 MemoryUsage* usage) { | |
525 while (usage->Exceeds(limit)) { | |
526 if (!*iterator) | |
527 return false; | |
528 | |
529 Tile* tile = **iterator; | |
530 if (!max_priority.IsHigherPriorityThan( | |
531 tile->priority_for_tree_priority(global_state_.tree_priority))) { | |
532 return false; | |
533 } | |
534 | |
535 *usage -= MemoryUsage::FromTile(tile); | |
536 FreeResourcesForTileAndNotifyClientIfTileWasReadyToDraw(tile); | |
537 ++(*iterator); | |
538 } | |
539 return true; | |
540 } | |
541 | |
542 bool TileManager::TilePriorityViolatesMemoryPolicy( | |
543 const TilePriority& priority) { | |
544 switch (global_state_.memory_limit_policy) { | |
545 case ALLOW_NOTHING: | |
546 return true; | |
547 case ALLOW_ABSOLUTE_MINIMUM: | |
548 return priority.priority_bin > TilePriority::NOW; | |
549 case ALLOW_PREPAINT_ONLY: | |
550 return priority.priority_bin > TilePriority::SOON; | |
551 case ALLOW_ANYTHING: | |
552 return priority.distance_to_visible == | |
553 std::numeric_limits<float>::infinity(); | |
554 } | |
555 NOTREACHED(); | |
556 return true; | |
557 } | |
558 | |
760 void TileManager::AssignGpuMemoryToTiles( | 559 void TileManager::AssignGpuMemoryToTiles( |
761 PrioritizedTileSet* tiles, | |
762 TileVector* tiles_that_need_to_be_rasterized) { | 560 TileVector* tiles_that_need_to_be_rasterized) { |
763 TRACE_EVENT0("cc", "TileManager::AssignGpuMemoryToTiles"); | 561 TRACE_EVENT0("cc", "TileManager::AssignGpuMemoryToTiles"); |
764 | 562 |
765 // Maintain the list of released resources that can potentially be re-used | 563 // Maintain the list of released resources that can potentially be re-used |
766 // or deleted. | 564 // or deleted. |
767 // If this operation becomes expensive too, only do this after some | 565 // 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 | 566 // resource(s) was returned. Note that in that case, one also need to |
769 // invalidate when releasing some resource from the pool. | 567 // invalidate when releasing some resource from the pool. |
770 resource_pool_->CheckBusyResources(); | 568 resource_pool_->CheckBusyResources(); |
771 | 569 |
772 // Now give memory out to the tiles until we're out, and build | 570 // Now give memory out to the tiles until we're out, and build |
773 // the needs-to-be-rasterized queue. | 571 // the needs-to-be-rasterized queue. |
774 all_tiles_that_need_to_be_rasterized_have_memory_ = true; | 572 all_tiles_that_need_to_be_rasterized_have_memory_ = true; |
775 all_tiles_required_for_activation_have_memory_ = true; | |
776 | 573 |
777 // Cast to prevent overflow. | 574 MemoryUsage hard_memory_limit(global_state_.hard_memory_limit_in_bytes, |
778 int64 soft_bytes_available = | 575 global_state_.num_resources_limit); |
779 static_cast<int64>(bytes_releasable_) + | 576 MemoryUsage soft_memory_limit(global_state_.soft_memory_limit_in_bytes, |
780 static_cast<int64>(global_state_.soft_memory_limit_in_bytes) - | 577 global_state_.num_resources_limit); |
781 static_cast<int64>(resource_pool_->acquired_memory_usage_bytes()); | 578 MemoryUsage memory_usage(resource_pool_->acquired_memory_usage_bytes(), |
782 int64 hard_bytes_available = | 579 resource_pool_->acquired_resource_count()); |
783 static_cast<int64>(bytes_releasable_) + | 580 |
784 static_cast<int64>(global_state_.hard_memory_limit_in_bytes) - | 581 EvictionTileIterator eviction_it(this, global_state_.tree_priority); |
785 static_cast<int64>(resource_pool_->acquired_memory_usage_bytes()); | 582 |
786 int resources_available = resources_releasable_ + | 583 FreeTileResourcesUntilUsageIsWithinLimit( |
787 global_state_.num_resources_limit - | 584 &eviction_it, hard_memory_limit, &memory_usage); |
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 | 585 |
795 size_t bytes_that_exceeded_memory_budget = 0; | 586 size_t bytes_that_exceeded_memory_budget = 0; |
reveman
2014/06/17 19:30:07
I don't think this function can produce a useful v
vmpstr
2014/06/17 21:34:05
I've added another spot where it's added (when we
| |
796 size_t soft_bytes_left = soft_bytes_allocatable; | |
797 size_t hard_bytes_left = hard_bytes_allocatable; | |
798 | 587 |
799 size_t resources_left = resources_allocatable; | |
800 bool oomed_soft = false; | 588 bool oomed_soft = false; |
801 bool oomed_hard = false; | 589 bool oomed_hard = false; |
802 bool have_hit_soft_memory = false; // Soft memory comes after hard. | 590 bool have_hit_soft_memory = false; // Soft memory comes after hard. |
803 | 591 |
804 unsigned schedule_priority = 1u; | 592 unsigned schedule_priority = 1u; |
805 for (PrioritizedTileSet::Iterator it(tiles, true); it; ++it) { | 593 RasterTileIterator it(this, global_state_.tree_priority); |
594 for (; it; ++it) { | |
806 Tile* tile = *it; | 595 Tile* tile = *it; |
596 TilePriority priority = | |
597 tile->priority_for_tree_priority(global_state_.tree_priority); | |
598 | |
599 if (TilePriorityViolatesMemoryPolicy(priority)) | |
600 break; | |
601 | |
807 ManagedTileState& mts = tile->managed_state(); | 602 ManagedTileState& mts = tile->managed_state(); |
808 | |
809 mts.scheduled_priority = schedule_priority++; | 603 mts.scheduled_priority = schedule_priority++; |
810 | |
811 mts.raster_mode = tile->DetermineOverallRasterMode(); | 604 mts.raster_mode = tile->DetermineOverallRasterMode(); |
812 | |
813 ManagedTileState::TileVersion& tile_version = | 605 ManagedTileState::TileVersion& tile_version = |
814 mts.tile_versions[mts.raster_mode]; | 606 mts.tile_versions[mts.raster_mode]; |
815 | 607 |
816 // If this tile doesn't need a resource, then nothing to do. | 608 DCHECK(!tile_version.IsReadyToDraw()); |
817 if (!tile_version.requires_resource()) | |
818 continue; | |
819 | 609 |
820 // If the tile is not needed, free it up. | 610 bool tile_uses_hard_limit = priority.priority_bin == TilePriority::NOW; |
821 if (mts.bin == NEVER_BIN) { | 611 MemoryUsage& memory_limit = |
822 FreeResourcesForTileAndNotifyClientIfTileWasReadyToDraw(tile); | 612 tile_uses_hard_limit ? hard_memory_limit : soft_memory_limit; |
823 continue; | |
824 } | |
825 | |
826 const bool tile_uses_hard_limit = mts.bin <= NOW_BIN; | |
827 const size_t bytes_if_allocated = BytesConsumedIfAllocated(tile); | 613 const size_t bytes_if_allocated = BytesConsumedIfAllocated(tile); |
reveman
2014/06/17 19:30:07
"const" here but nowhere else? is this temporary v
vmpstr
2014/06/17 21:34:06
Removed in favour of memory usage
| |
828 const size_t tile_bytes_left = | |
829 (tile_uses_hard_limit) ? hard_bytes_left : soft_bytes_left; | |
830 | 614 |
831 // Hard-limit is reserved for tiles that would cause a calamity | 615 // Hard-limit is reserved for tiles that would cause a calamity |
832 // if they were to go away, so by definition they are the highest | 616 // if they were to go away, so by definition they are the highest |
833 // priority memory, and must be at the front of the list. | 617 // priority memory, and must be at the front of the list. |
834 DCHECK(!(have_hit_soft_memory && tile_uses_hard_limit)); | 618 DCHECK(!(have_hit_soft_memory && tile_uses_hard_limit)); |
835 have_hit_soft_memory |= !tile_uses_hard_limit; | 619 have_hit_soft_memory |= !tile_uses_hard_limit; |
reveman
2014/06/17 19:30:07
Can we relax this now? I don't think we should enf
vmpstr
2014/06/17 21:34:05
Hmm.. This is still useful in the sense that we br
reveman
2014/06/17 22:26:07
I have to insist on removing this. I think it made
| |
836 | 620 |
837 size_t tile_bytes = 0; | 621 // If the tile version is not in flight, then we'll have to pay to create a |
838 size_t tile_resources = 0; | 622 // new task. |
623 MemoryUsage additional_memory_required; | |
reveman
2014/06/17 19:30:07
can you move this and all the code that use it int
vmpstr
2014/06/17 21:34:06
Done.
| |
624 if (!tile_version.raster_task_) | |
625 additional_memory_required = MemoryUsage(bytes_if_allocated, 1); | |
839 | 626 |
840 // It costs to maintain a resource. | 627 // Handle OOM tiles. |
841 for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) { | 628 bool memory_reduced_successfully = |
reveman
2014/06/17 19:30:07
I think this would be cleaner without a temporary
vmpstr
2014/06/17 21:34:05
I prefer the temporary, since I don't like putting
reveman
2014/06/17 22:26:07
Ok, that's fine. I don't think the comments make s
| |
842 if (mts.tile_versions[mode].resource_) { | 629 FreeTileResourcesWithLowerPriorityUntilUsageIsWithinLimit( |
843 tile_bytes += bytes_if_allocated; | 630 &eviction_it, |
844 tile_resources++; | 631 memory_limit - additional_memory_required, |
845 } | 632 priority, |
846 } | 633 &memory_usage); |
847 | 634 |
848 // Allow lower priority tiles with initialized resources to keep | 635 // Tile is still OOM. |
849 // their memory by only assigning memory to new raster tasks if | 636 if (!memory_reduced_successfully) { |
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(); | |
vmpstr
2014/06/17 18:23:22
I'm removing this bit. I don't think it's useful a
| |
873 | |
874 if (was_ready_to_draw) | |
875 client_->NotifyTileStateChanged(tile); | |
876 | |
877 oomed_soft = true; | 637 oomed_soft = true; |
878 if (tile_uses_hard_limit) { | 638 if (tile_uses_hard_limit) { |
879 oomed_hard = true; | 639 oomed_hard = true; |
880 bytes_that_exceeded_memory_budget += tile_bytes; | 640 bytes_that_exceeded_memory_budget += |
641 additional_memory_required.memory_bytes(); | |
881 } | 642 } |
882 } else { | 643 } else { |
883 resources_left -= tile_resources; | 644 memory_usage += additional_memory_required; |
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 } | 645 } |
890 | 646 |
891 DCHECK(!tile_version.resource_); | 647 DCHECK(!tile_version.resource_); |
892 | 648 |
893 // Tile shouldn't be rasterized if |tiles_that_need_to_be_rasterized| | 649 // 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 | 650 // 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 | 651 // or any higher priority tile. Preventing tiles that fit into memory |
896 // budget to be rasterized when higher priority tile is oom is | 652 // budget to be rasterized when higher priority tile is oom is |
897 // important for two reasons: | 653 // important for two reasons: |
898 // 1. Tile size should not impact raster priority. | 654 // 1. Tile size should not impact raster priority. |
899 // 2. Tiles with existing raster task could otherwise incorrectly | 655 // 2. Tiles with existing raster task could otherwise incorrectly |
900 // be added as they are not affected by |bytes_allocatable|. | 656 // be added as they are not affected by |bytes_allocatable|. |
901 bool can_schedule_tile = | 657 bool can_schedule_tile = |
902 !oomed_soft && !reached_scheduled_raster_tasks_limit; | 658 !oomed_soft && |
659 tiles_that_need_to_be_rasterized->size() < kScheduledRasterTasksLimit; | |
903 | 660 |
904 if (!can_schedule_tile) { | 661 if (!can_schedule_tile) { |
905 all_tiles_that_need_to_be_rasterized_have_memory_ = false; | 662 all_tiles_that_need_to_be_rasterized_have_memory_ = false; |
906 if (tile->required_for_activation()) | 663 break; |
907 all_tiles_required_for_activation_have_memory_ = false; | |
908 it.DisablePriorityOrdering(); | |
909 continue; | |
910 } | 664 } |
911 | 665 |
912 tiles_that_need_to_be_rasterized->push_back(tile); | 666 tiles_that_need_to_be_rasterized->push_back(tile); |
913 } | 667 } |
914 | 668 |
669 // Count up the memory that would be required on top of the allocated memory | |
670 // in order to initialize all visible tiles. | |
671 // TODO(vmpstr): Remove this once the memory manager doesn't need required | |
672 // bytes. | |
673 bytes_required_but_not_allocated_ = 0; | |
674 for (; it; ++it) { | |
675 Tile* tile = *it; | |
676 TilePriority priority = | |
677 tile->priority_for_tree_priority(global_state_.tree_priority); | |
678 | |
679 if (TilePriorityViolatesMemoryPolicy(priority) || | |
680 priority.priority_bin != TilePriority::NOW) | |
681 break; | |
682 | |
683 ManagedTileState& mts = tile->managed_state(); | |
684 mts.raster_mode = tile->DetermineOverallRasterMode(); | |
685 | |
686 ManagedTileState::TileVersion& tile_version = | |
687 mts.tile_versions[mts.raster_mode]; | |
688 | |
689 DCHECK(!tile_version.IsReadyToDraw()); | |
690 bytes_required_but_not_allocated_ += BytesConsumedIfAllocated(tile); | |
691 } | |
692 | |
915 // OOM reporting uses hard-limit, soft-OOM is normal depending on limit. | 693 // OOM reporting uses hard-limit, soft-OOM is normal depending on limit. |
916 ever_exceeded_memory_budget_ |= oomed_hard; | 694 ever_exceeded_memory_budget_ |= oomed_hard; |
917 if (ever_exceeded_memory_budget_) { | 695 if (ever_exceeded_memory_budget_) { |
918 TRACE_COUNTER_ID2("cc", | 696 TRACE_COUNTER_ID2("cc", |
919 "over_memory_budget", | 697 "over_memory_budget", |
920 this, | 698 this, |
921 "budget", | 699 "budget", |
922 global_state_.hard_memory_limit_in_bytes, | 700 global_state_.hard_memory_limit_in_bytes, |
923 "over", | 701 "over", |
924 bytes_that_exceeded_memory_budget); | 702 bytes_that_exceeded_memory_budget); |
925 } | 703 } |
926 memory_stats_from_last_assign_.total_budget_in_bytes = | 704 memory_stats_from_last_assign_.total_budget_in_bytes = |
927 global_state_.hard_memory_limit_in_bytes; | 705 global_state_.hard_memory_limit_in_bytes; |
928 memory_stats_from_last_assign_.bytes_allocated = | 706 memory_stats_from_last_assign_.bytes_allocated = |
929 hard_bytes_allocatable - hard_bytes_left; | 707 resource_pool_->acquired_memory_usage_bytes() - |
708 memory_usage.memory_bytes(); | |
reveman
2014/06/17 19:30:07
hm, should this be the other way around, "usage -
vmpstr
2014/06/17 21:34:05
You're right. Good catch
| |
930 memory_stats_from_last_assign_.bytes_unreleasable = | 709 memory_stats_from_last_assign_.bytes_unreleasable = |
931 resource_pool_->acquired_memory_usage_bytes() - bytes_releasable_; | 710 resource_pool_->acquired_memory_usage_bytes() - bytes_releasable_; |
932 memory_stats_from_last_assign_.bytes_over = bytes_that_exceeded_memory_budget; | 711 memory_stats_from_last_assign_.bytes_over = bytes_that_exceeded_memory_budget; |
933 } | 712 } |
934 | 713 |
935 void TileManager::FreeResourceForTile(Tile* tile, RasterMode mode) { | 714 void TileManager::FreeResourceForTile(Tile* tile, RasterMode mode) { |
936 ManagedTileState& mts = tile->managed_state(); | 715 ManagedTileState& mts = tile->managed_state(); |
937 if (mts.tile_versions[mode].resource_) { | 716 if (mts.tile_versions[mode].resource_) { |
938 resource_pool_->ReleaseResource(mts.tile_versions[mode].resource_.Pass()); | 717 resource_pool_->ReleaseResource(mts.tile_versions[mode].resource_.Pass()); |
939 | 718 |
(...skipping 230 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1170 content_rect, | 949 content_rect, |
1171 opaque_rect, | 950 opaque_rect, |
1172 contents_scale, | 951 contents_scale, |
1173 layer_id, | 952 layer_id, |
1174 source_frame_number, | 953 source_frame_number, |
1175 flags)); | 954 flags)); |
1176 DCHECK(tiles_.find(tile->id()) == tiles_.end()); | 955 DCHECK(tiles_.find(tile->id()) == tiles_.end()); |
1177 | 956 |
1178 tiles_[tile->id()] = tile; | 957 tiles_[tile->id()] = tile; |
1179 used_layer_counts_[tile->layer_id()]++; | 958 used_layer_counts_[tile->layer_id()]++; |
1180 prioritized_tiles_dirty_ = true; | |
1181 return tile; | 959 return tile; |
1182 } | 960 } |
1183 | 961 |
1184 void TileManager::GetPairedPictureLayers( | 962 void TileManager::GetPairedPictureLayers( |
1185 std::vector<PairedPictureLayer>* paired_layers) const { | 963 std::vector<PairedPictureLayer>* paired_layers) const { |
1186 const std::vector<PictureLayerImpl*>& layers = client_->GetPictureLayers(); | 964 const std::vector<PictureLayerImpl*>& layers = client_->GetPictureLayers(); |
1187 | 965 |
1188 paired_layers->clear(); | 966 paired_layers->clear(); |
1189 // Reserve a maximum possible paired layers. | 967 // Reserve a maximum possible paired layers. |
1190 paired_layers->reserve(layers.size()); | 968 paired_layers->reserve(layers.size()); |
(...skipping 432 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1623 void TileManager::CheckIfReadyToActivate() { | 1401 void TileManager::CheckIfReadyToActivate() { |
1624 TRACE_EVENT0("cc", "TileManager::CheckIfReadyToActivate"); | 1402 TRACE_EVENT0("cc", "TileManager::CheckIfReadyToActivate"); |
1625 | 1403 |
1626 rasterizer_->CheckForCompletedTasks(); | 1404 rasterizer_->CheckForCompletedTasks(); |
1627 did_check_for_completed_tasks_since_last_schedule_tasks_ = true; | 1405 did_check_for_completed_tasks_since_last_schedule_tasks_ = true; |
1628 | 1406 |
1629 if (IsReadyToActivate()) | 1407 if (IsReadyToActivate()) |
1630 client_->NotifyReadyToActivate(); | 1408 client_->NotifyReadyToActivate(); |
1631 } | 1409 } |
1632 | 1410 |
1411 TileManager::MemoryUsage::MemoryUsage() : memory_bytes_(0), resource_count_(0) { | |
1412 } | |
1413 | |
1414 TileManager::MemoryUsage::MemoryUsage(int64 memory_bytes, int resource_count) | |
1415 : memory_bytes_(memory_bytes), resource_count_(resource_count) { | |
1416 } | |
1417 | |
1418 // static | |
1419 TileManager::MemoryUsage TileManager::MemoryUsage::FromConfig( | |
1420 const gfx::Size& size, | |
1421 ResourceFormat format) { | |
1422 return MemoryUsage(Resource::MemorySizeBytes(size, format), 1); | |
1423 } | |
1424 | |
1425 // static | |
1426 TileManager::MemoryUsage TileManager::MemoryUsage::FromTile(const Tile* tile) { | |
1427 const ManagedTileState& mts = tile->managed_state(); | |
1428 MemoryUsage total_usage; | |
1429 for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) { | |
1430 if (mts.tile_versions[mode].resource_) { | |
1431 total_usage += MemoryUsage::FromConfig( | |
1432 tile->size(), mts.tile_versions[mode].resource_->format()); | |
1433 } | |
1434 } | |
1435 return total_usage; | |
1436 } | |
1437 | |
1438 TileManager::MemoryUsage& TileManager::MemoryUsage::operator+=( | |
1439 const MemoryUsage& other) { | |
1440 memory_bytes_ += other.memory_bytes_; | |
1441 resource_count_ += other.resource_count_; | |
1442 return *this; | |
1443 } | |
1444 | |
1445 TileManager::MemoryUsage& TileManager::MemoryUsage::operator-=( | |
1446 const MemoryUsage& other) { | |
1447 memory_bytes_ -= other.memory_bytes_; | |
1448 resource_count_ -= other.resource_count_; | |
1449 return *this; | |
1450 } | |
1451 | |
1452 TileManager::MemoryUsage TileManager::MemoryUsage::operator-( | |
1453 const MemoryUsage& other) { | |
1454 MemoryUsage result = *this; | |
1455 result -= other; | |
1456 return result; | |
1457 } | |
1458 | |
1459 bool TileManager::MemoryUsage::Exceeds(const MemoryUsage& limit) const { | |
1460 return memory_bytes_ > limit.memory_bytes_ || | |
1461 resource_count_ > limit.resource_count_; | |
1462 } | |
1463 | |
1633 } // namespace cc | 1464 } // namespace cc |
OLD | NEW |