Collect device perf data at unsandboxed GPU process startup.

The data is then send back to browser process.

This CL only adds mojo links. No data actually collected.

Bug: 1039792
Change-Id: I11b1cb9876ebaff2b5fe164db476549e682412e8
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2031857Reviewed-by: Daniel Cheng <dcheng@chromium.org>
Reviewed-by: kylechar <kylechar@chromium.org>
Commit-Queue: Zhenyao Mo <zmo@chromium.org>
Cr-Commit-Position: refs/heads/master@{#738576}

components/viz/host/host_gpu_memory_buffer_manager_unittest.cc

@@ -148,8 +148,9 @@ class TestGpuService : public mojom::GpuService {
   void RequestCompleteGpuInfo(
       RequestCompleteGpuInfoCallback callback) override {}
 
-  void GetGpuSupportedRuntimeVersion(
-      GetGpuSupportedRuntimeVersionCallback callback) override {}
+  void GetGpuSupportedRuntimeVersionAndDevicePerfInfo(
+      GetGpuSupportedRuntimeVersionAndDevicePerfInfoCallback callback)
+      override {}
 #endif
 
   void RequestHDRStatus(RequestHDRStatusCallback callback) override {}

components/viz/service/gl/gpu_service_impl.cc

@@ -149,6 +149,7 @@ GpuServiceImpl::GpuServiceImpl(
     const base::Optional<gpu::GpuFeatureInfo>&
         gpu_feature_info_for_hardware_gpu,
     const gpu::GpuExtraInfo& gpu_extra_info,
+    const base::Optional<gpu::DevicePerfInfo>& device_perf_info,
     gpu::VulkanImplementation* vulkan_implementation,
     base::OnceCallback<void(bool /*immediately*/)> exit_callback)
     : main_runner_(base::ThreadTaskRunnerHandle::Get()),
@@ -160,6 +161,7 @@ GpuServiceImpl::GpuServiceImpl(
       gpu_info_for_hardware_gpu_(gpu_info_for_hardware_gpu),
       gpu_feature_info_for_hardware_gpu_(gpu_feature_info_for_hardware_gpu),
       gpu_extra_info_(gpu_extra_info),
+      device_perf_info_(device_perf_info),
 #if BUILDFLAG(ENABLE_VULKAN)
       vulkan_implementation_(vulkan_implementation),
 #endif
@@ -575,14 +577,15 @@ void GpuServiceImpl::GetPeakMemoryUsage(uint32_t sequence_num,
 }
 
 #if defined(OS_WIN)
-void GpuServiceImpl::GetGpuSupportedRuntimeVersion(
-    GetGpuSupportedRuntimeVersionCallback callback) {
+void GpuServiceImpl::GetGpuSupportedRuntimeVersionAndDevicePerfInfo(
+    GetGpuSupportedRuntimeVersionAndDevicePerfInfoCallback callback) {
   if (io_runner_->BelongsToCurrentThread()) {
     auto wrap_callback = WrapCallback(io_runner_, std::move(callback));
     main_runner_->PostTask(
         FROM_HERE,
-        base::BindOnce(&GpuServiceImpl::GetGpuSupportedRuntimeVersion,
-                       weak_ptr_, std::move(wrap_callback)));
+        base::BindOnce(
+            &GpuServiceImpl::GetGpuSupportedRuntimeVersionAndDevicePerfInfo,
+            weak_ptr_, std::move(wrap_callback)));
     return;
   }
   DCHECK(main_runner_->BelongsToCurrentThread());
@@ -594,7 +597,9 @@ void GpuServiceImpl::GetGpuSupportedRuntimeVersion(
 
   gpu::RecordGpuSupportedRuntimeVersionHistograms(
       &gpu_info_.dx12_vulkan_version_info);
-  std::move(callback).Run(gpu_info_.dx12_vulkan_version_info);
+  DCHECK(device_perf_info_.has_value());
+  std::move(callback).Run(gpu_info_.dx12_vulkan_version_info,
+                          device_perf_info_.value());
 
   // The unsandboxed GPU process fulfilled its duty and Dxdiag task is not
   // running. Bye bye.

components/viz/service/gl/gpu_service_impl.h

@@ -22,6 +22,7 @@
 #include "gpu/command_buffer/client/gpu_memory_buffer_manager.h"
 #include "gpu/command_buffer/common/activity_flags.h"
 #include "gpu/command_buffer/service/sequence_id.h"
+#include "gpu/config/device_perf_info.h"
 #include "gpu/config/gpu_extra_info.h"
 #include "gpu/config/gpu_info.h"
 #include "gpu/config/gpu_preferences.h"
@@ -87,6 +88,7 @@ class VIZ_SERVICE_EXPORT GpuServiceImpl : public gpu::GpuChannelManagerDelegate,
                  const base::Optional<gpu::GpuFeatureInfo>&
                      gpu_feature_info_for_hardware_gpu,
                  const gpu::GpuExtraInfo& gpu_extra_info,
+                 const base::Optional<gpu::DevicePerfInfo>& device_perf_info,
                  gpu::VulkanImplementation* vulkan_implementation,
                  base::OnceCallback<void(bool /*immediately*/)> exit_callback);
 
@@ -160,8 +162,8 @@ class VIZ_SERVICE_EXPORT GpuServiceImpl : public gpu::GpuChannelManagerDelegate,
 
 #if defined(OS_WIN)
   void RequestCompleteGpuInfo(RequestCompleteGpuInfoCallback callback) override;
-  void GetGpuSupportedRuntimeVersion(
-      GetGpuSupportedRuntimeVersionCallback callback) override;
+  void GetGpuSupportedRuntimeVersionAndDevicePerfInfo(
+      GetGpuSupportedRuntimeVersionAndDevicePerfInfoCallback callback) override;
 #endif
   void RequestHDRStatus(RequestHDRStatusCallback callback) override;
   void LoadedShader(int32_t client_id,
@@ -345,6 +347,10 @@ class VIZ_SERVICE_EXPORT GpuServiceImpl : public gpu::GpuChannelManagerDelegate,
   // Information about the GPU process populated on creation.
   gpu::GpuExtraInfo gpu_extra_info_;
 
+  // Information related to device perf category, only collected on the second
+  // unsandboxed GPU process.
+  base::Optional<gpu::DevicePerfInfo> device_perf_info_;
+
   mojo::SharedRemote<mojom::GpuHost> gpu_host_;
   std::unique_ptr<gpu::GpuChannelManager> gpu_channel_manager_;
   std::unique_ptr<media::MediaGpuChannelManager> media_gpu_channel_manager_;

components/viz/service/gl/gpu_service_impl_unittest.cc

@@ -73,6 +73,7 @@ class GpuServiceTest : public testing::Test {
         gpu_info, /*watchdog_thread=*/nullptr, io_thread_.task_runner(),
         gpu::GpuFeatureInfo(), gpu::GpuPreferences(), gpu::GPUInfo(),
         gpu::GpuFeatureInfo(), gpu::GpuExtraInfo(),
+        /*device_perf_info=*/base::nullopt,
         /*vulkan_implementation=*/nullptr,
         /*exit_callback=*/base::DoNothing());
   }

components/viz/service/main/viz_main_impl.cc

@@ -100,7 +100,8 @@ VizMainImpl::VizMainImpl(Delegate* delegate,
       gpu_init_->gpu_feature_info(), gpu_init_->gpu_preferences(),
       gpu_init_->gpu_info_for_hardware_gpu(),
       gpu_init_->gpu_feature_info_for_hardware_gpu(),
-      gpu_init_->gpu_extra_info(), gpu_init_->vulkan_implementation(),
+      gpu_init_->gpu_extra_info(), gpu_init_->device_perf_info(),
+      gpu_init_->vulkan_implementation(),
       base::BindOnce(&VizMainImpl::ExitProcess, base::Unretained(this)));
 }
 

components/viz/test/test_gpu_service_holder.cc

@@ -217,6 +217,7 @@ void TestGpuServiceHolder::InitializeOnGpuThread(
       /*gpu_info_for_hardware_gpu=*/gpu::GPUInfo(),
       /*gpu_feature_info_for_hardware_gpu=*/gpu::GpuFeatureInfo(),
       /*gpu_extra_info=*/gpu::GpuExtraInfo(),
+      /*device_perf_info=*/base::nullopt,
 #if BUILDFLAG(ENABLE_VULKAN)
       vulkan_implementation_.get(),
 #else

content/browser/gpu/gpu_data_manager_impl_private.cc

@@ -666,9 +666,11 @@ void GpuDataManagerImplPrivate::RequestGpuSupportedRuntimeVersion(
     }
 
     GpuDataManagerImpl::GetInstance()->UpdateDx12VulkanRequestStatus(true);
-    host->gpu_service()->GetGpuSupportedRuntimeVersion(
-        base::BindOnce([](const gpu::Dx12VulkanVersionInfo& info) {
+    host->gpu_service()->GetGpuSupportedRuntimeVersionAndDevicePerfInfo(
+        base::BindOnce([](const gpu::Dx12VulkanVersionInfo& info,
+                          const gpu::DevicePerfInfo& device_perf_info) {
           GpuDataManagerImpl::GetInstance()->UpdateDx12VulkanInfo(info);
+          // TODO(zmo): Process collected DevicePerfInfo.
         }));
   });
 
@@ -990,6 +992,7 @@ void GpuDataManagerImplPrivate::UpdateGpuPreferences(
 #if defined(OS_WIN)
   if (kind == GPU_PROCESS_KIND_UNSANDBOXED_NO_GL) {
     gpu_preferences->disable_gpu_watchdog = true;
+    gpu_preferences->enable_perf_data_collection = true;
   }
 #endif
 

content/browser/gpu/peak_gpu_memory_tracker_impl_browsertest.cc

@@ -95,8 +95,9 @@ class TestGpuService : public viz::mojom::GpuService {
 #if defined(OS_WIN)
   void RequestCompleteGpuInfo(
       RequestCompleteGpuInfoCallback callback) override {}
-  void GetGpuSupportedRuntimeVersion(
-      GetGpuSupportedRuntimeVersionCallback callback) override {}
+  void GetGpuSupportedRuntimeVersionAndDevicePerfInfo(
+      GetGpuSupportedRuntimeVersionAndDevicePerfInfoCallback callback)
+      override {}
 #endif
   void RequestHDRStatus(RequestHDRStatusCallback callback) override {}
   void LoadedShader(int32_t client_id,

gpu/config/BUILD.gn

@@ -111,6 +111,7 @@ jumbo_source_set("config_sources") {
   visibility = [ "//gpu/*" ]
 
   sources = [
+    "device_perf_info.h",
     "dx_diag_node.cc",
     "dx_diag_node.h",
     "gpu_blocklist.cc",

gpu/config/device_perf_info.h

+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef GPU_CONFIG_DEVICE_PERF_INFO_H_
+#define GPU_CONFIG_DEVICE_PERF_INFO_H_
+
+#include <string>
+#include <vector>
+
+#include "gpu/gpu_export.h"
+
+namespace gpu {
+
+struct GPU_EXPORT DevicePerfInfo {
+  uint32_t score = 0;
+};
+
+}  // namespace gpu
+
+#endif  // GPU_CONFIG_DEVICE_PERF_INFO_H_

gpu/config/gpu_preferences.h

@@ -239,6 +239,10 @@ struct GPU_EXPORT GpuPreferences {
   // Enable measuring blocked time on GPU Main thread
   bool enable_gpu_blocked_time_metric = false;
 
+  // Enable collecting perf data for device categorization purpose. Currently
+  // only enabled on Windows platform for the info collection GPU process.
+  bool enable_perf_data_collection = false;
+
 #if defined(USE_OZONE)
   // Determines message pump type for the GPU thread.
   base::MessagePumpType message_pump_type = base::MessagePumpType::DEFAULT;

gpu/config/gpu_preferences_unittest.cc

@@ -77,6 +77,8 @@ void CheckGpuPreferencesEqual(GpuPreferences left, GpuPreferences right) {
   EXPECT_EQ(left.enable_webgpu, right.enable_webgpu);
   EXPECT_EQ(left.enable_gpu_blocked_time_metric,
             right.enable_gpu_blocked_time_metric);
+  EXPECT_EQ(left.enable_perf_data_collection,
+            right.enable_perf_data_collection);
 #if defined(USE_OZONE)
   EXPECT_EQ(left.message_pump_type, right.message_pump_type);
 #endif
@@ -168,6 +170,7 @@ TEST(GpuPreferencesTest, EncodeDecode) {
     GPU_PREFERENCES_FIELD(enable_gpu_benchmarking_extension, true)
     GPU_PREFERENCES_FIELD(enable_webgpu, true)
     GPU_PREFERENCES_FIELD(enable_gpu_blocked_time_metric, true)
+    GPU_PREFERENCES_FIELD(enable_perf_data_collection, true)
 #if defined(USE_OZONE)
     GPU_PREFERENCES_FIELD_ENUM(message_pump_type, base::MessagePumpType::UI,
                                base::MessagePumpType::UI)

gpu/ipc/common/BUILD.gn

@@ -198,6 +198,7 @@ mojom("interfaces") {
   sources = [
     "capabilities.mojom",
     "context_result.mojom",
+    "device_perf_info.mojom",
     "dx_diag_node.mojom",
     "gpu_extra_info.mojom",
     "gpu_feature_info.mojom",

gpu/ipc/common/device_perf_info.mojom

+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+module gpu.mojom;
+
+// Corresponds to |gpu::DevicePerfInfo| in file gpu/config/device_perf_info.h
+struct DevicePerfInfo {
+  uint32 score;
+};

gpu/ipc/common/device_perf_info.typemap

+# Copyright 2020 The Chromium Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+mojom = "//gpu/ipc/common/device_perf_info.mojom"
+public_headers = [ "//gpu/config/device_perf_info.h" ]
+traits_headers = [ "//gpu/ipc/common/device_perf_info_mojom_traits.h" ]
+sources = [ "//gpu/ipc/common/device_perf_info_mojom_traits.cc" ]
+type_mappings = [ "gpu.mojom.DevicePerfInfo=::gpu::DevicePerfInfo" ]

gpu/ipc/common/device_perf_info_mojom_traits.cc

+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "gpu/ipc/common/device_perf_info_mojom_traits.h"
+
+namespace mojo {
+
+// static
+bool StructTraits<gpu::mojom::DevicePerfInfoDataView, gpu::DevicePerfInfo>::
+    Read(gpu::mojom::DevicePerfInfoDataView data, gpu::DevicePerfInfo* out) {
+  out->score = data.score();
+  return true;
+}
+
+}  // namespace mojo

gpu/ipc/common/device_perf_info_mojom_traits.h

+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef GPU_IPC_COMMON_DEVICE_PERF_INFO_MOJOM_TRAITS_H_
+#define GPU_IPC_COMMON_DEVICE_PERF_INFO_MOJOM_TRAITS_H_
+
+#include "gpu/ipc/common/device_perf_info.mojom.h"
+
+namespace mojo {
+
+template <>
+struct StructTraits<gpu::mojom::DevicePerfInfoDataView, gpu::DevicePerfInfo> {
+  static bool Read(gpu::mojom::DevicePerfInfoDataView data,
+                   gpu::DevicePerfInfo* out);
+
+  static uint32_t score(const gpu::DevicePerfInfo& info) { return info.score; }
+};
+
+}  // namespace mojo
+
+#endif  // GPU_IPC_COMMON_DEVICE_PERF_INFO_MOJOM_TRAITS_H_

gpu/ipc/common/gpu_preferences.mojom

@@ -84,6 +84,7 @@ struct GpuPreferences {
   bool enable_gpu_benchmarking_extension;
   bool enable_webgpu;
   bool enable_gpu_blocked_time_metric;
+  bool enable_perf_data_collection;
 
   [EnableIf=use_ozone]
   mojo_base.mojom.MessagePumpType message_pump_type;

gpu/ipc/common/gpu_preferences_mojom_traits.h

@@ -172,6 +172,7 @@ struct StructTraits<gpu::mojom::GpuPreferencesDataView, gpu::GpuPreferences> {
     out->enable_webgpu = prefs.enable_webgpu();
     out->enable_gpu_blocked_time_metric =
         prefs.enable_gpu_blocked_time_metric();
+    out->enable_perf_data_collection = prefs.enable_perf_data_collection();
 
 #if defined(USE_OZONE)
     if (!prefs.ReadMessagePumpType(&out->message_pump_type))
@@ -344,6 +345,9 @@ struct StructTraits<gpu::mojom::GpuPreferencesDataView, gpu::GpuPreferences> {
   static bool enable_gpu_blocked_time_metric(const gpu::GpuPreferences& prefs) {
     return prefs.enable_gpu_blocked_time_metric;
   }
+  static bool enable_perf_data_collection(const gpu::GpuPreferences& prefs) {
+    return prefs.enable_perf_data_collection;
+  }
 #if defined(USE_OZONE)
   static base::MessagePumpType message_pump_type(
       const gpu::GpuPreferences& prefs) {

gpu/ipc/common/typemaps.gni

@@ -5,11 +5,12 @@
 typemaps = [
   "//gpu/ipc/common/capabilities.typemap",
   "//gpu/ipc/common/context_result.typemap",
+  "//gpu/ipc/common/device_perf_info.typemap",
+  "//gpu/ipc/common/dx_diag_node.typemap",
   "//gpu/ipc/common/gpu_feature_info.typemap",
   "//gpu/ipc/common/gpu_info.typemap",
   "//gpu/ipc/common/gpu_preferences.typemap",
   "//gpu/ipc/common/gpu_extra_info.typemap",
-  "//gpu/ipc/common/dx_diag_node.typemap",
   "//gpu/ipc/common/mailbox.typemap",
   "//gpu/ipc/common/mailbox_holder.typemap",
   "//gpu/ipc/common/memory_stats.typemap",

gpu/ipc/service/gpu_init.cc

@@ -135,6 +135,12 @@ class GpuWatchdogInit {
  private:
   gpu::GpuWatchdogThread* watchdog_ptr_ = nullptr;
 };
+
+DevicePerfInfo CollectDevicePerfInfo() {
+  // TODO(zmo): Collect perf info.
+  DevicePerfInfo info;
+  return info;
+}
 }  // namespace
 
 GpuInit::GpuInit() = default;
@@ -146,6 +152,12 @@ GpuInit::~GpuInit() {
 bool GpuInit::InitializeAndStartSandbox(base::CommandLine* command_line,
                                         const GpuPreferences& gpu_preferences) {
   gpu_preferences_ = gpu_preferences;
+
+  if (gpu_preferences_.enable_perf_data_collection) {
+    // This is only enabled on the info collection GPU process.
+    device_perf_info_ = CollectDevicePerfInfo();
+  }
+
   // Blacklist decisions based on basic GPUInfo may not be final. It might
   // need more context based GPUInfo. In such situations, switching to
   // SwiftShader needs to wait until creating a context.

gpu/ipc/service/gpu_init.h

@@ -7,6 +7,7 @@
 
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
+#include "gpu/config/device_perf_info.h"
 #include "gpu/config/gpu_extra_info.h"
 #include "gpu/config/gpu_feature_info.h"
 #include "gpu/config/gpu_info.h"
@@ -64,6 +65,9 @@ class GPU_IPC_SERVICE_EXPORT GpuInit {
       const {
     return gpu_feature_info_for_hardware_gpu_;
   }
+  const base::Optional<DevicePerfInfo>& device_perf_info() const {
+    return device_perf_info_;
+  }
   const GpuPreferences& gpu_preferences() const { return gpu_preferences_; }
   std::unique_ptr<GpuWatchdogThread> TakeWatchdogThread() {
     return std::move(watchdog_thread_);
@@ -96,6 +100,9 @@ class GPU_IPC_SERVICE_EXPORT GpuInit {
 
   GpuExtraInfo gpu_extra_info_;
 
+  // The following data are collected by the info collection GPU process.
+  base::Optional<DevicePerfInfo> device_perf_info_;
+
 #if BUILDFLAG(ENABLE_VULKAN)
   std::unique_ptr<VulkanImplementation> vulkan_implementation_;
 #endif

services/viz/privileged/mojom/gl/gpu_service.mojom

@@ -16,6 +16,7 @@ import "components/arc/mojom/video_protected_buffer_allocator.mojom";
 import "components/chromeos_camera/common/mjpeg_decode_accelerator.mojom";
 [EnableIf=is_chromeos]
 import "components/chromeos_camera/common/jpeg_encode_accelerator.mojom";
+import "gpu/ipc/common/device_perf_info.mojom";
 import "gpu/ipc/common/dx_diag_node.mojom";
 import "gpu/ipc/common/gpu_info.mojom";
 import "gpu/ipc/common/memory_stats.mojom";
@@ -100,9 +101,18 @@ interface GpuService {
 
   [EnableIf=is_win]
   RequestCompleteGpuInfo() => (gpu.mojom.DxDiagNode dx_diagnostics);
+
+  // Requests Vulkan and DX12 supports and device performance info on Windows.
+  // Returning whether Vulkan and DX12 are supported, and if yes, the
+  // supported version/feature level, together with a few metrics related
+  // to the device's performance for about:gpu and histogram recording
+  // purpose.
+  // TODO(crbug.com/1028263): histograms need to be recorded at browser process
+  // for now.
   [EnableIf=is_win]
-  GetGpuSupportedRuntimeVersion()
-      => (gpu.mojom.Dx12VulkanVersionInfo dx12_vulkan_version_info);
+  GetGpuSupportedRuntimeVersionAndDevicePerfInfo()
+      => (gpu.mojom.Dx12VulkanVersionInfo dx12_vulkan_version_info,
+          gpu.mojom.DevicePerfInfo device_perf_info);
 
   // Requests that the GPU process query system availability of HDR output and
   // return it.