chrome/browser/task_management/sampling/task_manager_impl.cc

   1 // Copyright 2015 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 "chrome/browser/task_management/sampling/task_manager_impl.h"
   6
   7 #include "base/stl_util.h"
   8 #include "chrome/browser/task_management/providers/browser_process_task_provider.h"
   9 #include "chrome/browser/task_management/providers/child_process_task_provider.h"
  10 #include "chrome/browser/task_management/providers/web_contents/web_contents_task_provider.h"
  11 #include "content/public/browser/browser_thread.h"
  12 #include "content/public/browser/gpu_data_manager.h"
  13
  14 namespace task_management {
  15
  16 namespace {
  17
  18 inline scoped_refptr<base::SequencedTaskRunner> GetBlockingPoolRunner() {
  19   base::SequencedWorkerPool* blocking_pool =
  20       content::BrowserThread::GetBlockingPool();
  21   base::SequencedWorkerPool::SequenceToken token =
  22       blocking_pool->GetSequenceToken();
  23
  24   DCHECK(token.IsValid());
  25
  26   return blocking_pool->GetSequencedTaskRunner(token);
  27 }
  28
  29 base::LazyInstance<TaskManagerImpl> lazy_task_manager_instance =
  30     LAZY_INSTANCE_INITIALIZER;
  31
  32 }  // namespace
  33
  34 TaskManagerImpl::TaskManagerImpl()
  35     : blocking_pool_runner_(GetBlockingPoolRunner()),
  36       is_running_(false) {
  37   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
  38
  39   task_providers_.push_back(new BrowserProcessTaskProvider());
  40   task_providers_.push_back(new ChildProcessTaskProvider());
  41   task_providers_.push_back(new WebContentsTaskProvider());
  42
  43   content::GpuDataManager::GetInstance()->AddObserver(this);
  44 }
  45
  46 TaskManagerImpl::~TaskManagerImpl() {
  47   content::GpuDataManager::GetInstance()->RemoveObserver(this);
  48
  49   STLDeleteValues(&task_groups_by_proc_id_);
  50 }
  51
  52 // static
  53 TaskManagerImpl* TaskManagerImpl::GetInstance() {
  54   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
  55
  56   return lazy_task_manager_instance.Pointer();
  57 }
  58
  59 void TaskManagerImpl::ActivateTask(TaskId task_id) {
  60   GetTaskByTaskId(task_id)->Activate();
  61 }
  62
  63 double TaskManagerImpl::GetCpuUsage(TaskId task_id) const {
  64   return GetTaskGroupByTaskId(task_id)->cpu_usage();
  65 }
  66
  67 int64 TaskManagerImpl::GetPhysicalMemoryUsage(TaskId task_id) const {
  68   return GetTaskGroupByTaskId(task_id)->physical_bytes();
  69 }
  70
  71 int64 TaskManagerImpl::GetPrivateMemoryUsage(TaskId task_id) const {
  72   return GetTaskGroupByTaskId(task_id)->private_bytes();
  73 }
  74
  75 int64 TaskManagerImpl::GetSharedMemoryUsage(TaskId task_id) const {
  76   return GetTaskGroupByTaskId(task_id)->shared_bytes();
  77 }
  78
  79 int64 TaskManagerImpl::GetGpuMemoryUsage(TaskId task_id,
  80                                          bool* has_duplicates) const {
  81   const TaskGroup* task_group = GetTaskGroupByTaskId(task_id);
  82   if (has_duplicates)
  83     *has_duplicates = task_group->gpu_memory_has_duplicates();
  84   return task_group->gpu_memory();
  85 }
  86
  87 int TaskManagerImpl::GetIdleWakeupsPerSecond(TaskId task_id) const {
  88   return GetTaskGroupByTaskId(task_id)->idle_wakeups_per_second();
  89 }
  90
  91 int TaskManagerImpl::GetNaClDebugStubPort(TaskId task_id) const {
  92 #if !defined(DISABLE_NACL)
  93   return GetTaskGroupByTaskId(task_id)->nacl_debug_stub_port();
  94 #else
  95   return -1;
  96 #endif  // !defined(DISABLE_NACL)
  97 }
  98
  99 void TaskManagerImpl::GetGDIHandles(TaskId task_id,
 100                                     int64* current,
 101                                     int64* peak) const {
 102 #if defined(OS_WIN)
 103   const TaskGroup* task_group = GetTaskGroupByTaskId(task_id);
 104   *current = task_group->gdi_current_handles();
 105   *peak = task_group->gdi_peak_handles();
 106 #else
 107   *current = -1;
 108   *peak = -1;
 109 #endif  // defined(OS_WIN)
 110 }
 111
 112 void TaskManagerImpl::GetUSERHandles(TaskId task_id,
 113                                      int64* current,
 114                                      int64* peak) const {
 115 #if defined(OS_WIN)
 116   const TaskGroup* task_group = GetTaskGroupByTaskId(task_id);
 117   *current = task_group->user_current_handles();
 118   *peak = task_group->user_peak_handles();
 119 #else
 120   *current = -1;
 121   *peak = -1;
 122 #endif  // defined(OS_WIN)
 123 }
 124
 125 const base::string16& TaskManagerImpl::GetTitle(TaskId task_id) const {
 126   return GetTaskByTaskId(task_id)->title();
 127 }
 128
 129 base::string16 TaskManagerImpl::GetProfileName(TaskId task_id) const {
 130   return GetTaskByTaskId(task_id)->GetProfileName();
 131 }
 132
 133 const gfx::ImageSkia& TaskManagerImpl::GetIcon(TaskId task_id) const {
 134   return GetTaskByTaskId(task_id)->icon();
 135 }
 136
 137 const base::ProcessHandle& TaskManagerImpl::GetProcessHandle(
 138     TaskId task_id) const {
 139   return GetTaskGroupByTaskId(task_id)->process_handle();
 140 }
 141
 142 const base::ProcessId& TaskManagerImpl::GetProcessId(TaskId task_id) const {
 143   return GetTaskGroupByTaskId(task_id)->process_id();
 144 }
 145
 146 Task::Type TaskManagerImpl::GetType(TaskId task_id) const {
 147   return GetTaskByTaskId(task_id)->GetType();
 148 }
 149
 150 int64 TaskManagerImpl::GetNetworkUsage(TaskId task_id) const {
 151   return GetTaskByTaskId(task_id)->network_usage();
 152 }
 153
 154 int64 TaskManagerImpl::GetSqliteMemoryUsed(TaskId task_id) const {
 155   return GetTaskByTaskId(task_id)->GetSqliteMemoryUsed();
 156 }
 157
 158 bool TaskManagerImpl::GetV8Memory(TaskId task_id,
 159                                   int64* allocated,
 160                                   int64* used) const {
 161   const Task* task = GetTaskByTaskId(task_id);
 162   if (!task->ReportsV8Memory())
 163     return false;
 164
 165   *allocated = task->GetV8MemoryAllocated();
 166   *used = task->GetV8MemoryUsed();
 167
 168   return true;
 169 }
 170
 171 bool TaskManagerImpl::GetWebCacheStats(
 172     TaskId task_id,
 173     blink::WebCache::ResourceTypeStats* stats) const {
 174   const Task* task = GetTaskByTaskId(task_id);
 175   if (!task->ReportsWebCacheStats())
 176     return false;
 177
 178   *stats = task->GetWebCacheStats();
 179
 180   return true;
 181 }
 182
 183 const TaskIdList& TaskManagerImpl::GetTaskIdsList() const {
 184   DCHECK(is_running_) << "Task manager is not running. You must observe the "
 185       "task manager for it to start running";
 186
 187   if (sorted_task_ids_.empty()) {
 188     sorted_task_ids_.reserve(task_groups_by_task_id_.size());
 189     for (const auto& groups_pair : task_groups_by_proc_id_)
 190       groups_pair.second->AppendSortedTaskIds(&sorted_task_ids_);
 191   }
 192
 193   return sorted_task_ids_;
 194 }
 195
 196 size_t TaskManagerImpl::GetNumberOfTasksOnSameProcess(TaskId task_id) const {
 197   return GetTaskGroupByTaskId(task_id)->num_tasks();
 198 }
 199
 200 void TaskManagerImpl::TaskAdded(Task* task) {
 201   DCHECK(task);
 202
 203   TaskGroup* task_group = nullptr;
 204   const base::ProcessId proc_id = task->process_id();
 205   const TaskId task_id = task->task_id();
 206
 207   auto itr = task_groups_by_proc_id_.find(proc_id);
 208   if (itr == task_groups_by_proc_id_.end()) {
 209     task_group = new TaskGroup(task->process_handle(),
 210                                proc_id,
 211                                blocking_pool_runner_);
 212     task_groups_by_proc_id_[proc_id] = task_group;
 213   } else {
 214     task_group = itr->second;
 215   }
 216
 217   task_group->AddTask(task);
 218
 219   task_groups_by_task_id_[task_id] = task_group;
 220
 221   // Invalidate the cached sorted IDs by clearing the list.
 222   sorted_task_ids_.clear();
 223
 224   NotifyObserversOnTaskAdded(task_id);
 225 }
 226
 227 void TaskManagerImpl::TaskRemoved(Task* task) {
 228   DCHECK(task);
 229
 230   const base::ProcessId proc_id = task->process_id();
 231   const TaskId task_id = task->task_id();
 232
 233   DCHECK(ContainsKey(task_groups_by_proc_id_, proc_id));
 234   DCHECK(ContainsKey(task_groups_by_task_id_, task_id));
 235
 236   NotifyObserversOnTaskToBeRemoved(task_id);
 237
 238   TaskGroup* task_group = task_groups_by_proc_id_.at(proc_id);
 239   task_group->RemoveTask(task);
 240
 241   task_groups_by_task_id_.erase(task_id);
 242
 243   // Invalidate the cached sorted IDs by clearing the list.
 244   sorted_task_ids_.clear();
 245
 246   if (task_group->empty()) {
 247     task_groups_by_proc_id_.erase(proc_id);
 248     delete task_group;
 249   }
 250 }
 251
 252 void TaskManagerImpl::OnVideoMemoryUsageStatsUpdate(
 253     const content::GPUVideoMemoryUsageStats& gpu_memory_stats) {
 254   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 255
 256   gpu_memory_stats_ = gpu_memory_stats;
 257 }
 258
 259 // static
 260 void TaskManagerImpl::OnMultipleBytesReadUI(
 261     std::vector<BytesReadParam>* params) {
 262   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 263   DCHECK(params);
 264
 265   for (BytesReadParam& param : *params) {
 266     if (!GetInstance()->UpdateTasksWithBytesRead(param)) {
 267       // We can't match a task to the notification.  That might mean the
 268       // tab that started a download was closed, or the request may have had
 269       // no originating task associated with it in the first place.
 270       // We attribute orphaned/unaccounted activity to the Browser process.
 271       DCHECK(param.origin_pid || (param.child_id != -1));
 272
 273       param.origin_pid = 0;
 274       param.child_id = param.route_id = -1;
 275
 276       GetInstance()->UpdateTasksWithBytesRead(param);
 277     }
 278   }
 279 }
 280
 281 void TaskManagerImpl::Refresh() {
 282   if (IsResourceRefreshEnabled(REFRESH_TYPE_GPU_MEMORY)) {
 283     content::GpuDataManager::GetInstance()->
 284         RequestVideoMemoryUsageStatsUpdate();
 285   }
 286
 287   for (auto& groups_itr : task_groups_by_proc_id_) {
 288     groups_itr.second->Refresh(gpu_memory_stats_,
 289                                GetCurrentRefreshTime(),
 290                                enabled_resources_flags());
 291   }
 292
 293   TaskIdList task_ids(GetTaskIdsList());
 294   NotifyObserversOnRefresh(task_ids);
 295 }
 296
 297 void TaskManagerImpl::StartUpdating() {
 298   is_running_ = true;
 299
 300   for (auto& provider : task_providers_)
 301     provider->SetObserver(this);
 302
 303   io_thread_helper_manager_.reset(new IoThreadHelperManager);
 304 }
 305
 306 void TaskManagerImpl::StopUpdating() {
 307   is_running_ = false;
 308
 309   io_thread_helper_manager_.reset();
 310
 311   for (auto& provider : task_providers_)
 312     provider->ClearObserver();
 313
 314   STLDeleteValues(&task_groups_by_proc_id_);
 315   task_groups_by_task_id_.clear();
 316   sorted_task_ids_.clear();
 317 }
 318
 319 bool TaskManagerImpl::UpdateTasksWithBytesRead(const BytesReadParam& param) {
 320   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 321
 322   for (auto& task_provider : task_providers_) {
 323     Task* task = task_provider->GetTaskOfUrlRequest(param.origin_pid,
 324                                                     param.child_id,
 325                                                     param.route_id);
 326     if (task) {
 327       task->OnNetworkBytesRead(param.byte_count);
 328       return true;
 329     }
 330   }
 331
 332   // Couldn't match the bytes to any existing task.
 333   return false;
 334 }
 335
 336 TaskGroup* TaskManagerImpl::GetTaskGroupByTaskId(TaskId task_id) const {
 337   DCHECK(ContainsKey(task_groups_by_task_id_, task_id));
 338
 339   return task_groups_by_task_id_.at(task_id);
 340 }
 341
 342 Task* TaskManagerImpl::GetTaskByTaskId(TaskId task_id) const {
 343   return GetTaskGroupByTaskId(task_id)->GetTaskById(task_id);
 344 }
 345
 346 }  // namespace task_management