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