Stack sampling profiler: run the profiler in the GPU process on trunk builds

chrome/common/stack_sampling_configuration.cc

 // Copyright 2015 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 "chrome/common/stack_sampling_configuration.h"
 
+#include "base/command_line.h"
+#include "base/lazy_instance.h"
 #include "base/rand_util.h"
 #include "chrome/common/channel_info.h"
+#include "chrome/common/chrome_switches.h"
 #include "components/version_info/version_info.h"
+#include "content/public/common/content_switches.h"
 
 namespace {
 
+static base::LazyInstance<StackSamplingConfiguration>::Leaky g_configuration =
+    LAZY_INSTANCE_INITIALIZER;
+
 // The profiler is currently only implemented for Windows x64, and only runs on
 // trunk, canary, and dev.
 bool IsProfilerSupported() {
 #if !defined(_WIN64)
   return false;
 #else
   const version_info::Channel channel = chrome::GetChannel();
   return (channel == version_info::Channel::UNKNOWN ||
           channel == version_info::Channel::CANARY ||
           channel == version_info::Channel::DEV);
 #endif
 }
 
+bool ExecutingInBrowserProcess() {

[Ilya Sherman, 2016/09/28 01:02:15]

nit: I'd prepend an "Is" to this name.  And, please add a brief doc string =)

[Mike Wittman, 2016/09/28 19:34:26]

Changed to IsBrowserProcess. IsExecutingInBrowserProcess sounded strange to me
since the implicit subject is a thread, and the thread itself is not really
relevant here. Added a doc string.

+  const base::CommandLine* command_line =
+      base::CommandLine::ForCurrentProcess();
+  std::string process_type =
+      command_line->GetSwitchValueASCII(switches::kProcessType);
+  return process_type.empty();
+}
+
 }  // namespace
 
 StackSamplingConfiguration::StackSamplingConfiguration()
     : configuration_(GenerateConfiguration()) {
 }
 
 base::StackSamplingProfiler::SamplingParams
-StackSamplingConfiguration::GetSamplingParams() const {
+StackSamplingConfiguration::GetSamplingParamsForCurrentProcess() const {
   base::StackSamplingProfiler::SamplingParams params;
   params.bursts = 1;
-  const base::TimeDelta duration = base::TimeDelta::FromSeconds(30);
+  params.initial_delay = base::TimeDelta::FromMilliseconds(0);
+  params.sampling_interval = base::TimeDelta::FromMilliseconds(0);
+  params.samples_per_burst = 0;
 
-  switch (configuration_) {
-    case PROFILE_DISABLED:
-    case PROFILE_CONTROL:
-      params.initial_delay = base::TimeDelta::FromMilliseconds(0);
-      params.sampling_interval = base::TimeDelta::FromMilliseconds(0);
-      params.samples_per_burst = 0;
-      break;
+  if (IsProfilerEnabledForCurrentProcess()) {
+    const base::TimeDelta duration = base::TimeDelta::FromSeconds(30);
+    params.sampling_interval = base::TimeDelta::FromMilliseconds(100);
+    params.samples_per_burst = duration / params.sampling_interval;
+  }
 
-    case PROFILE_NO_SAMPLES:
-      params.initial_delay = duration;
-      params.sampling_interval = base::TimeDelta::FromMilliseconds(0);
-      params.samples_per_burst = 0;
-      break;
-
-    case PROFILE_5HZ:
-      params.initial_delay = base::TimeDelta::FromMilliseconds(0);
-      params.sampling_interval = base::TimeDelta::FromMilliseconds(200);
-      params.samples_per_burst = duration / params.sampling_interval;
-      break;
-
-    case PROFILE_10HZ:
-      params.initial_delay = base::TimeDelta::FromMilliseconds(0);
-      params.sampling_interval = base::TimeDelta::FromMilliseconds(100);
-      params.samples_per_burst = duration / params.sampling_interval;
-      break;
-
-    case PROFILE_100HZ:
-      params.initial_delay = base::TimeDelta::FromMilliseconds(0);
-      params.sampling_interval = base::TimeDelta::FromMilliseconds(10);
-      params.samples_per_burst = duration / params.sampling_interval;
-      break;
-  }
   return params;
 }
 
-bool StackSamplingConfiguration::IsProfilerEnabled() const {
-  return (configuration_ != PROFILE_DISABLED &&
-          configuration_ != PROFILE_CONTROL);
+bool StackSamplingConfiguration::IsProfilerEnabledForCurrentProcess() const {
+  if (ExecutingInBrowserProcess()) {
+    return configuration_ == PROFILE_BROWSER_PROCESS ||
+        configuration_ == PROFILE_BROWSER_AND_GPU_PROCESS;
+  }
+
+  DCHECK(configuration_ == PROFILE_FROM_COMMAND_LINE);

[Ilya Sherman, 2016/09/28 01:02:15]

nit: DCHECK_EQ

[Mike Wittman, 2016/09/28 19:34:26]

Done.

+  // This is a child process. The kStartStackProfiler switch passed by the
+  // browser process determines whether the profiler is enabled for the process.
+  const base::CommandLine* command_line =
+      base::CommandLine::ForCurrentProcess();
+  return command_line->HasSwitch(switches::kStartStackProfiler);
 }
 
 void StackSamplingConfiguration::RegisterSyntheticFieldTrial(
     const RegisterSyntheticFieldTrialFunction& register_field_trial) const {
+  DCHECK(ExecutingInBrowserProcess());
+
   if (!IsProfilerSupported())
     return;
 
   std::string group;
   switch (configuration_) {
     case PROFILE_DISABLED:
       group = "Disabled";
       break;
 
     case PROFILE_CONTROL:
       group = "Control";
       break;
 
-    case PROFILE_NO_SAMPLES:
-      group = "NoSamples";
+    case PROFILE_BROWSER_PROCESS:
+      group = "BrowserProcess";
       break;
 
-    case PROFILE_5HZ:
-      group = "5Hz";
+    case PROFILE_GPU_PROCESS:
+      group = "GpuProcess";
       break;
 
-    case PROFILE_10HZ:
-      group = "10Hz";
+    case PROFILE_BROWSER_AND_GPU_PROCESS:
+      group = "BrowserAndGpuProcess";
       break;
 
-    case PROFILE_100HZ:
-      group = "100Hz";
+    case PROFILE_FROM_COMMAND_LINE:
+      NOTREACHED();
       break;
   }
 
   register_field_trial.Run("SyntheticStackProfilingConfiguration", group);
 }
 
+void StackSamplingConfiguration::AppendCommandLineSwitchForChildProcess(
+    const std::string process_type,
+    base::CommandLine* command_line) const {
+  DCHECK(ExecutingInBrowserProcess());
+
+  if (process_type == switches::kGpuProcess &&
+      (configuration_ == PROFILE_GPU_PROCESS ||
+       configuration_ == PROFILE_BROWSER_AND_GPU_PROCESS)) {
+    command_line->AppendSwitch(switches::kStartStackProfiler);
+  }
+}
+
+// static
+StackSamplingConfiguration* StackSamplingConfiguration::Get() {
+  return g_configuration.Pointer();
+}
+
 // static
 StackSamplingConfiguration::ProfileConfiguration
 StackSamplingConfiguration::GenerateConfiguration() {
+  if (!ExecutingInBrowserProcess())
+    return PROFILE_FROM_COMMAND_LINE;
+
   if (!IsProfilerSupported())
     return PROFILE_DISABLED;
 
-  // Enable the profiler in the intended ultimate production configuration for
+  // Enable the profiler in the ultimate production configuration for
   // development/waterfall builds.
   if (chrome::GetChannel() == version_info::Channel::UNKNOWN)
-    return PROFILE_10HZ;
+    return PROFILE_BROWSER_AND_GPU_PROCESS;
 
   // Enable according to the variations below in canary and dev.
   if (chrome::GetChannel() == version_info::Channel::CANARY ||
       chrome::GetChannel() == version_info::Channel::DEV) {
     struct Variation {
       ProfileConfiguration config;
       int weight;
     };
 
     // Generate a configuration according to the associated weights.
     const Variation variations[] = {
-      { PROFILE_10HZ, 100},
+      { PROFILE_BROWSER_PROCESS, 100},
+      { PROFILE_GPU_PROCESS, 0},
+      { PROFILE_BROWSER_AND_GPU_PROCESS, 0},
       { PROFILE_CONTROL, 0},
       { PROFILE_DISABLED, 0}
     };
 
     int total_weight = 0;
     for (const Variation& variation : variations)
       total_weight += variation.weight;
     DCHECK_EQ(100, total_weight);
 
     int chosen = base::RandInt(0, total_weight - 1);  // Max is inclusive.
     int cumulative_weight = 0;
     for (const Variation& variation : variations) {
       if (chosen >= cumulative_weight &&
           chosen < cumulative_weight + variation.weight) {
         return variation.config;
       }
       cumulative_weight += variation.weight;
     }
     NOTREACHED();
   }
 
   return PROFILE_DISABLED;
 }