Home | History | Annotate | Download | only in gpu 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "content/common/gpu/gpu_memory_manager.h"
      6 
      7 #include <algorithm>
      8 
      9 #include "base/bind.h"
     10 #include "base/command_line.h"
     11 #include "base/debug/trace_event.h"
     12 #include "base/message_loop/message_loop.h"
     13 #include "base/process/process_handle.h"
     14 #include "base/strings/string_number_conversions.h"
     15 #include "content/common/gpu/gpu_channel_manager.h"
     16 #include "content/common/gpu/gpu_memory_manager_client.h"
     17 #include "content/common/gpu/gpu_memory_tracking.h"
     18 #include "content/common/gpu/gpu_memory_uma_stats.h"
     19 #include "content/common/gpu/gpu_messages.h"
     20 #include "gpu/command_buffer/common/gpu_memory_allocation.h"
     21 #include "gpu/command_buffer/service/gpu_switches.h"
     22 
     23 using gpu::MemoryAllocation;
     24 
     25 namespace content {
     26 namespace {
     27 
     28 const int kDelayedScheduleManageTimeoutMs = 67;
     29 
     30 const uint64 kBytesAllocatedUnmanagedStep = 16 * 1024 * 1024;
     31 
     32 void TrackValueChanged(uint64 old_size, uint64 new_size, uint64* total_size) {
     33   DCHECK(new_size > old_size || *total_size >= (old_size - new_size));
     34   *total_size += (new_size - old_size);
     35 }
     36 
     37 }
     38 
     39 GpuMemoryManager::GpuMemoryManager(
     40     GpuChannelManager* channel_manager,
     41     uint64 max_surfaces_with_frontbuffer_soft_limit)
     42     : channel_manager_(channel_manager),
     43       manage_immediate_scheduled_(false),
     44       disable_schedule_manage_(false),
     45       max_surfaces_with_frontbuffer_soft_limit_(
     46           max_surfaces_with_frontbuffer_soft_limit),
     47       client_hard_limit_bytes_(0),
     48       bytes_allocated_managed_current_(0),
     49       bytes_allocated_unmanaged_current_(0),
     50       bytes_allocated_historical_max_(0)
     51 { }
     52 
     53 GpuMemoryManager::~GpuMemoryManager() {
     54   DCHECK(tracking_groups_.empty());
     55   DCHECK(clients_visible_mru_.empty());
     56   DCHECK(clients_nonvisible_mru_.empty());
     57   DCHECK(clients_nonsurface_.empty());
     58   DCHECK(!bytes_allocated_managed_current_);
     59   DCHECK(!bytes_allocated_unmanaged_current_);
     60 }
     61 
     62 void GpuMemoryManager::UpdateAvailableGpuMemory() {
     63   // If the value was overridden on the command line, use the specified value.
     64   static bool client_hard_limit_bytes_overridden =
     65       base::CommandLine::ForCurrentProcess()->HasSwitch(
     66           switches::kForceGpuMemAvailableMb);
     67   if (client_hard_limit_bytes_overridden) {
     68     base::StringToUint64(
     69         base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
     70             switches::kForceGpuMemAvailableMb),
     71         &client_hard_limit_bytes_);
     72     client_hard_limit_bytes_ *= 1024 * 1024;
     73     return;
     74   }
     75 
     76 #if defined(OS_ANDROID)
     77   // On non-Android, we use an operating system query when possible.
     78   // We do not have a reliable concept of multiple GPUs existing in
     79   // a system, so just be safe and go with the minimum encountered.
     80   uint64 bytes_min = 0;
     81 
     82   // Only use the clients that are visible, because otherwise the set of clients
     83   // we are querying could become extremely large.
     84   for (ClientStateList::const_iterator it = clients_visible_mru_.begin();
     85       it != clients_visible_mru_.end();
     86       ++it) {
     87     const GpuMemoryManagerClientState* client_state = *it;
     88     if (!client_state->has_surface_)
     89       continue;
     90     if (!client_state->visible_)
     91       continue;
     92 
     93     uint64 bytes = 0;
     94     if (client_state->client_->GetTotalGpuMemory(&bytes)) {
     95       if (!bytes_min || bytes < bytes_min)
     96         bytes_min = bytes;
     97     }
     98   }
     99 
    100   client_hard_limit_bytes_ = bytes_min;
    101   // Clamp the observed value to a specific range on Android.
    102   client_hard_limit_bytes_ = std::max(client_hard_limit_bytes_,
    103                                       static_cast<uint64>(16 * 1024 * 1024));
    104   client_hard_limit_bytes_ = std::min(client_hard_limit_bytes_,
    105                                       static_cast<uint64>(256 * 1024 * 1024));
    106 #else
    107   // Ignore what the system said and give all clients the same maximum
    108   // allocation on desktop platforms.
    109   client_hard_limit_bytes_ = 512 * 1024 * 1024;
    110 #endif
    111 }
    112 
    113 void GpuMemoryManager::ScheduleManage(
    114     ScheduleManageTime schedule_manage_time) {
    115   if (disable_schedule_manage_)
    116     return;
    117   if (manage_immediate_scheduled_)
    118     return;
    119   if (schedule_manage_time == kScheduleManageNow) {
    120     base::MessageLoop::current()->PostTask(
    121         FROM_HERE, base::Bind(&GpuMemoryManager::Manage, AsWeakPtr()));
    122     manage_immediate_scheduled_ = true;
    123     if (!delayed_manage_callback_.IsCancelled())
    124       delayed_manage_callback_.Cancel();
    125   } else {
    126     if (!delayed_manage_callback_.IsCancelled())
    127       return;
    128     delayed_manage_callback_.Reset(base::Bind(&GpuMemoryManager::Manage,
    129                                               AsWeakPtr()));
    130     base::MessageLoop::current()->PostDelayedTask(
    131         FROM_HERE,
    132         delayed_manage_callback_.callback(),
    133         base::TimeDelta::FromMilliseconds(kDelayedScheduleManageTimeoutMs));
    134   }
    135 }
    136 
    137 void GpuMemoryManager::TrackMemoryAllocatedChange(
    138     GpuMemoryTrackingGroup* tracking_group,
    139     uint64 old_size,
    140     uint64 new_size,
    141     gpu::gles2::MemoryTracker::Pool tracking_pool) {
    142   TrackValueChanged(old_size, new_size, &tracking_group->size_);
    143   switch (tracking_pool) {
    144     case gpu::gles2::MemoryTracker::kManaged:
    145       TrackValueChanged(old_size, new_size, &bytes_allocated_managed_current_);
    146       break;
    147     case gpu::gles2::MemoryTracker::kUnmanaged:
    148       TrackValueChanged(old_size,
    149                         new_size,
    150                         &bytes_allocated_unmanaged_current_);
    151       break;
    152     default:
    153       NOTREACHED();
    154       break;
    155   }
    156   if (new_size != old_size) {
    157     TRACE_COUNTER1("gpu",
    158                    "GpuMemoryUsage",
    159                    GetCurrentUsage());
    160   }
    161 
    162   if (GetCurrentUsage() > bytes_allocated_historical_max_ +
    163                           kBytesAllocatedUnmanagedStep) {
    164       bytes_allocated_historical_max_ = GetCurrentUsage();
    165       // If we're blowing into new memory usage territory, spam the browser
    166       // process with the most up-to-date information about our memory usage.
    167       SendUmaStatsToBrowser();
    168   }
    169 }
    170 
    171 bool GpuMemoryManager::EnsureGPUMemoryAvailable(uint64 /* size_needed */) {
    172   // TODO: Check if there is enough space. Lose contexts until there is.
    173   return true;
    174 }
    175 
    176 GpuMemoryManagerClientState* GpuMemoryManager::CreateClientState(
    177     GpuMemoryManagerClient* client,
    178     bool has_surface,
    179     bool visible) {
    180   TrackingGroupMap::iterator tracking_group_it =
    181       tracking_groups_.find(client->GetMemoryTracker());
    182   DCHECK(tracking_group_it != tracking_groups_.end());
    183   GpuMemoryTrackingGroup* tracking_group = tracking_group_it->second;
    184 
    185   GpuMemoryManagerClientState* client_state = new GpuMemoryManagerClientState(
    186       this, client, tracking_group, has_surface, visible);
    187   AddClientToList(client_state);
    188   ScheduleManage(kScheduleManageNow);
    189   return client_state;
    190 }
    191 
    192 void GpuMemoryManager::OnDestroyClientState(
    193     GpuMemoryManagerClientState* client_state) {
    194   RemoveClientFromList(client_state);
    195   ScheduleManage(kScheduleManageLater);
    196 }
    197 
    198 void GpuMemoryManager::SetClientStateVisible(
    199     GpuMemoryManagerClientState* client_state, bool visible) {
    200   DCHECK(client_state->has_surface_);
    201   if (client_state->visible_ == visible)
    202     return;
    203 
    204   RemoveClientFromList(client_state);
    205   client_state->visible_ = visible;
    206   AddClientToList(client_state);
    207   ScheduleManage(visible ? kScheduleManageNow : kScheduleManageLater);
    208 }
    209 
    210 uint64 GpuMemoryManager::GetClientMemoryUsage(
    211     const GpuMemoryManagerClient* client) const {
    212   TrackingGroupMap::const_iterator tracking_group_it =
    213       tracking_groups_.find(client->GetMemoryTracker());
    214   DCHECK(tracking_group_it != tracking_groups_.end());
    215   return tracking_group_it->second->GetSize();
    216 }
    217 
    218 GpuMemoryTrackingGroup* GpuMemoryManager::CreateTrackingGroup(
    219     base::ProcessId pid, gpu::gles2::MemoryTracker* memory_tracker) {
    220   GpuMemoryTrackingGroup* tracking_group = new GpuMemoryTrackingGroup(
    221       pid, memory_tracker, this);
    222   DCHECK(!tracking_groups_.count(tracking_group->GetMemoryTracker()));
    223   tracking_groups_.insert(std::make_pair(tracking_group->GetMemoryTracker(),
    224                                          tracking_group));
    225   return tracking_group;
    226 }
    227 
    228 void GpuMemoryManager::OnDestroyTrackingGroup(
    229     GpuMemoryTrackingGroup* tracking_group) {
    230   DCHECK(tracking_groups_.count(tracking_group->GetMemoryTracker()));
    231   tracking_groups_.erase(tracking_group->GetMemoryTracker());
    232 }
    233 
    234 void GpuMemoryManager::GetVideoMemoryUsageStats(
    235     GPUVideoMemoryUsageStats* video_memory_usage_stats) const {
    236   // For each context group, assign its memory usage to its PID
    237   video_memory_usage_stats->process_map.clear();
    238   for (TrackingGroupMap::const_iterator i =
    239        tracking_groups_.begin(); i != tracking_groups_.end(); ++i) {
    240     const GpuMemoryTrackingGroup* tracking_group = i->second;
    241     video_memory_usage_stats->process_map[
    242         tracking_group->GetPid()].video_memory += tracking_group->GetSize();
    243   }
    244 
    245   // Assign the total across all processes in the GPU process
    246   video_memory_usage_stats->process_map[
    247       base::GetCurrentProcId()].video_memory = GetCurrentUsage();
    248   video_memory_usage_stats->process_map[
    249       base::GetCurrentProcId()].has_duplicates = true;
    250 
    251   video_memory_usage_stats->bytes_allocated = GetCurrentUsage();
    252   video_memory_usage_stats->bytes_allocated_historical_max =
    253       bytes_allocated_historical_max_;
    254 }
    255 
    256 void GpuMemoryManager::Manage() {
    257   manage_immediate_scheduled_ = false;
    258   delayed_manage_callback_.Cancel();
    259 
    260   // Update the amount of GPU memory available on the system.
    261   UpdateAvailableGpuMemory();
    262 
    263   // Determine which clients are "hibernated" (which determines the
    264   // distribution of frontbuffers and memory among clients that don't have
    265   // surfaces).
    266   SetClientsHibernatedState();
    267 
    268   // Assign memory allocations to clients that have surfaces.
    269   AssignSurfacesAllocations();
    270 
    271   // Assign memory allocations to clients that don't have surfaces.
    272   AssignNonSurfacesAllocations();
    273 
    274   SendUmaStatsToBrowser();
    275 }
    276 
    277 void GpuMemoryManager::AssignSurfacesAllocations() {
    278   // Send that allocation to the clients.
    279   ClientStateList clients = clients_visible_mru_;
    280   clients.insert(clients.end(),
    281                  clients_nonvisible_mru_.begin(),
    282                  clients_nonvisible_mru_.end());
    283   for (ClientStateList::const_iterator it = clients.begin();
    284        it != clients.end();
    285        ++it) {
    286     GpuMemoryManagerClientState* client_state = *it;
    287 
    288     // Populate and send the allocation to the client
    289     MemoryAllocation allocation;
    290     allocation.bytes_limit_when_visible = client_hard_limit_bytes_;
    291 #if defined(OS_ANDROID)
    292     // On Android, because there is only one visible tab at any time, allow
    293     // that renderer to cache as much as it can.
    294     allocation.priority_cutoff_when_visible =
    295         MemoryAllocation::CUTOFF_ALLOW_EVERYTHING;
    296 #else
    297     // On desktop platforms, instruct the renderers to cache only a smaller
    298     // set, to play nice with other renderers and other applications. If this
    299     // if not done, then the system can become unstable.
    300     // http://crbug.com/145600 (Linux)
    301     // http://crbug.com/141377 (Mac)
    302     allocation.priority_cutoff_when_visible =
    303         MemoryAllocation::CUTOFF_ALLOW_NICE_TO_HAVE;
    304 #endif
    305 
    306     client_state->client_->SetMemoryAllocation(allocation);
    307     client_state->client_->SuggestHaveFrontBuffer(!client_state->hibernated_);
    308   }
    309 }
    310 
    311 void GpuMemoryManager::AssignNonSurfacesAllocations() {
    312   for (ClientStateList::const_iterator it = clients_nonsurface_.begin();
    313        it != clients_nonsurface_.end();
    314        ++it) {
    315     GpuMemoryManagerClientState* client_state = *it;
    316     MemoryAllocation allocation;
    317 
    318     if (!client_state->hibernated_) {
    319       allocation.bytes_limit_when_visible = client_hard_limit_bytes_;
    320       allocation.priority_cutoff_when_visible =
    321           MemoryAllocation::CUTOFF_ALLOW_EVERYTHING;
    322     }
    323 
    324     client_state->client_->SetMemoryAllocation(allocation);
    325   }
    326 }
    327 
    328 void GpuMemoryManager::SetClientsHibernatedState() const {
    329   // Re-set all tracking groups as being hibernated.
    330   for (TrackingGroupMap::const_iterator it = tracking_groups_.begin();
    331        it != tracking_groups_.end();
    332        ++it) {
    333     GpuMemoryTrackingGroup* tracking_group = it->second;
    334     tracking_group->hibernated_ = true;
    335   }
    336   // All clients with surfaces that are visible are non-hibernated.
    337   uint64 non_hibernated_clients = 0;
    338   for (ClientStateList::const_iterator it = clients_visible_mru_.begin();
    339        it != clients_visible_mru_.end();
    340        ++it) {
    341     GpuMemoryManagerClientState* client_state = *it;
    342     client_state->hibernated_ = false;
    343     client_state->tracking_group_->hibernated_ = false;
    344     non_hibernated_clients++;
    345   }
    346   // Then an additional few clients with surfaces are non-hibernated too, up to
    347   // a fixed limit.
    348   for (ClientStateList::const_iterator it = clients_nonvisible_mru_.begin();
    349        it != clients_nonvisible_mru_.end();
    350        ++it) {
    351     GpuMemoryManagerClientState* client_state = *it;
    352     if (non_hibernated_clients < max_surfaces_with_frontbuffer_soft_limit_) {
    353       client_state->hibernated_ = false;
    354       client_state->tracking_group_->hibernated_ = false;
    355       non_hibernated_clients++;
    356     } else {
    357       client_state->hibernated_ = true;
    358     }
    359   }
    360   // Clients that don't have surfaces are non-hibernated if they are
    361   // in a GL share group with a non-hibernated surface.
    362   for (ClientStateList::const_iterator it = clients_nonsurface_.begin();
    363        it != clients_nonsurface_.end();
    364        ++it) {
    365     GpuMemoryManagerClientState* client_state = *it;
    366     client_state->hibernated_ = client_state->tracking_group_->hibernated_;
    367   }
    368 }
    369 
    370 void GpuMemoryManager::SendUmaStatsToBrowser() {
    371   if (!channel_manager_)
    372     return;
    373   GPUMemoryUmaStats params;
    374   params.bytes_allocated_current = GetCurrentUsage();
    375   params.bytes_allocated_max = bytes_allocated_historical_max_;
    376   params.bytes_limit = client_hard_limit_bytes_;
    377   params.client_count = clients_visible_mru_.size() +
    378                         clients_nonvisible_mru_.size() +
    379                         clients_nonsurface_.size();
    380   params.context_group_count = tracking_groups_.size();
    381   channel_manager_->Send(new GpuHostMsg_GpuMemoryUmaStats(params));
    382 }
    383 
    384 GpuMemoryManager::ClientStateList* GpuMemoryManager::GetClientList(
    385     GpuMemoryManagerClientState* client_state) {
    386   if (client_state->has_surface_) {
    387     if (client_state->visible_)
    388       return &clients_visible_mru_;
    389     else
    390       return &clients_nonvisible_mru_;
    391   }
    392   return &clients_nonsurface_;
    393 }
    394 
    395 void GpuMemoryManager::AddClientToList(
    396     GpuMemoryManagerClientState* client_state) {
    397   DCHECK(!client_state->list_iterator_valid_);
    398   ClientStateList* client_list = GetClientList(client_state);
    399   client_state->list_iterator_ = client_list->insert(
    400       client_list->begin(), client_state);
    401   client_state->list_iterator_valid_ = true;
    402 }
    403 
    404 void GpuMemoryManager::RemoveClientFromList(
    405     GpuMemoryManagerClientState* client_state) {
    406   DCHECK(client_state->list_iterator_valid_);
    407   ClientStateList* client_list = GetClientList(client_state);
    408   client_list->erase(client_state->list_iterator_);
    409   client_state->list_iterator_valid_ = false;
    410 }
    411 
    412 }  // namespace content
    413