Stack sampling profiler: enable at 10% for GPU process on canary

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"
@@ skipping 46 matching lines @@
     const base::TimeDelta duration = base::TimeDelta::FromSeconds(30);
     params.sampling_interval = base::TimeDelta::FromMilliseconds(100);
     params.samples_per_burst = duration / params.sampling_interval;
   }
 
   return params;
 }
 
 bool StackSamplingConfiguration::IsProfilerEnabledForCurrentProcess() const {
   if (IsBrowserProcess()) {
-    return configuration_ == PROFILE_BROWSER_PROCESS ||
-        configuration_ == PROFILE_BROWSER_AND_GPU_PROCESS;
+    switch (configuration_) {
+      case PROFILE_BROWSER_PROCESS:
+      case PROFILE_BROWSER_AND_GPU_PROCESS:
+      case PROFILE_CONTROL:
+        return true;
+
+      default:
+        return false;
+    }
   }
 
   DCHECK_EQ(PROFILE_FROM_COMMAND_LINE, configuration_);
   // 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);
 }
 
@@ skipping 48 matching lines @@
   }
 }
 
 // static
 StackSamplingConfiguration* StackSamplingConfiguration::Get() {
   return g_configuration.Pointer();
 }
 
 // static
 StackSamplingConfiguration::ProfileConfiguration
+StackSamplingConfiguration::ChooseConfiguration(
+    const std::vector<Variation>& variations) {
+  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;
+}

[Ilya Sherman, 2016/10/12 20:52:31]

Hmm, it looks like you're re-implementing the field trial mechanism.  Why?

[Mike Wittman, 2016/10/12 21:50:41]

The profiler can't use the standard field trial mechanism because it runs before
the field trials are initialized.

[Ilya Sherman, 2016/10/12 22:16:17]

Ah, makes sense -- thanks for the reminder.  Is this documented somewhere
already alongside the code?  If so, I didn't spot it.

[Mike Wittman, 2016/10/12 23:00:32]

Not explicitly. Added to the comment on GetSyntheticFieldTrial.

+
+// static
+StackSamplingConfiguration::ProfileConfiguration
 StackSamplingConfiguration::GenerateConfiguration() {
   if (!IsBrowserProcess())
     return PROFILE_FROM_COMMAND_LINE;
 
   if (!IsProfilerSupported())
     return PROFILE_DISABLED;
 
-  // Enable the profiler in the ultimate production configuration for
-  // development/waterfall builds.
-  if (chrome::GetChannel() == version_info::Channel::UNKNOWN)
-    return PROFILE_BROWSER_AND_GPU_PROCESS;
+  switch (chrome::GetChannel()) {
+    // Enable the profiler in the ultimate production configuration for
+    // development/waterfall builds.
+    case version_info::Channel::UNKNOWN:
+      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;
-    };
+    case version_info::Channel::CANARY:
+      return ChooseConfiguration({
+        { PROFILE_BROWSER_PROCESS, 80},
+        { PROFILE_GPU_PROCESS, 0},
+        { PROFILE_BROWSER_AND_GPU_PROCESS, 10},
+        { PROFILE_CONTROL, 10},
+        { PROFILE_DISABLED, 0}
+      });
 
-    // Generate a configuration according to the associated weights.
-    const Variation variations[] = {
-      { 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();
+    case version_info::Channel::DEV:
+      return ChooseConfiguration({
+        { PROFILE_BROWSER_PROCESS, 100},
+        { PROFILE_GPU_PROCESS, 0},
+        { PROFILE_BROWSER_AND_GPU_PROCESS, 0},
+        { PROFILE_CONTROL, 0},
+        { PROFILE_DISABLED, 0}
+      });
   }
 
   return PROFILE_DISABLED;
 }