Initialize the TaskScheduler with Variation Parameters if Available

chrome/browser/chrome_browser_main.cc

 // Copyright (c) 2012 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/browser/chrome_browser_main.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
+#include <algorithm>
+#include <map>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/at_exit.h"
 #include "base/base_switches.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/crash_logging.h"
 #include "base/debug/debugger.h"
 #include "base/feature_list.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
+#include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/path_service.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_split.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/sys_info.h"
+#include "base/task_scheduler/scheduler_worker_pool_params.h"
+#include "base/task_scheduler/task_scheduler.h"
+#include "base/task_scheduler/task_traits.h"
 #include "base/threading/platform_thread.h"
 #include "base/time/default_tick_clock.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "cc/base/switches.h"
 #include "chrome/browser/about_flags.h"
 #include "chrome/browser/after_startup_task_utils.h"
 #include "chrome/browser/browser_process.h"
@@ skipping 264 matching lines @@
 void AddFirstRunNewTabs(StartupBrowserCreator* browser_creator,
                         const std::vector<GURL>& new_tabs) {
   for (std::vector<GURL>::const_iterator it = new_tabs.begin();
        it != new_tabs.end(); ++it) {
     if (it->is_valid())
       browser_creator->AddFirstRunTab(*it);
   }
 }
 #endif  // !defined(OS_ANDROID) && !defined(OS_CHROMEOS)
 
+enum WorkerPoolType : size_t {
+  BACKGROUND_WORKER_POOL = 0,
+  BACKGROUND_FILE_IO_WORKER_POOL,
+  FOREGROUND_WORKER_POOL,
+  FOREGROUND_FILE_IO_WORKER_POOL,
+  WORKER_POOL_COUNT,
+};
+
+struct WorkerPoolVariationValues {
+  int threads = 0;
+  base::TimeDelta detach_period;
+};
+
+// Converts |pool_descriptor| to a WorkerPoolVariationValues. Returns a default
+// WorkerPoolVariationValues on failure.
+//
+// |pool_descriptor| is a comma separated value string with the following items:
+// 1. Minimum Thread Count (int)
+// 2. Maximum Thread Count (int)
+// 3. Thread Count Multiplier (double)
+// 4. Thread Count Offset (int)
+// 5. Detach Time in Milliseconds (milliseconds)
+// Additional values may appear as necessary and will be ignored.
+WorkerPoolVariationValues StringToWorkerPoolVariationValues(
+    const base::StringPiece& pool_descriptor) {
+  const std::vector<std::string> tokens =
+      SplitString(pool_descriptor, ",",
+                  base::KEEP_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
+  int minimum;
+  int maximum;
+  double multiplier;
+  int offset;
+  int detach_milliseconds;
+  // Checking for a size greater than the expected amount allows us to be
+  // forward compatible if we add more variation values.
+  if (tokens.size() >= 5 &&
+      base::StringToInt(tokens[0], &minimum) &&
+      base::StringToInt(tokens[1], &maximum) &&
+      base::StringToDouble(tokens[2], &multiplier) &&
+      base::StringToInt(tokens[3], &offset) &&
+      base::StringToInt(tokens[4], &detach_milliseconds)) {
+    const int num_of_cores = base::SysInfo::NumberOfProcessors();
+    const int threads = std::round<int>(num_of_cores * multiplier) + offset;
+    WorkerPoolVariationValues values;
+    values.threads = std::min(maximum, std::max(minimum, threads));
+    values.detach_period =
+        base::TimeDelta::FromMilliseconds(detach_milliseconds);
+    return values;
+  }
+  LOG(WARNING) << "Invalid Worker Pool Descriptor: " << pool_descriptor;
+  return WorkerPoolVariationValues();
+}
+
+// Returns the worker pool index for |traits| defaulting to
+// FOREGROUND_WORKER_POOL or FOREGROUND_FILE_IO_WORKER_POOL on unknown
+// priorities.
+size_t WorkerPoolIndexForTraits(const base::TaskTraits& traits) {
+  if (traits.with_file_io()) {
+    return traits.priority() == base::TaskPriority::BACKGROUND
+               ? BACKGROUND_FILE_IO_WORKER_POOL
+               : FOREGROUND_FILE_IO_WORKER_POOL;
+  }
+  return traits.priority() == base::TaskPriority::BACKGROUND
+      ? BACKGROUND_WORKER_POOL
+      : FOREGROUND_WORKER_POOL;
+}
+
+// Initializes the Default Browser Task Scheduler if there is a valid variation
+// parameter for the field trial.
+void MaybeInitializeTaskScheduler() {
+  static constexpr char kFieldTrialName[] = "BrowserScheduler";
+  std::map<std::string, std::string> variation_params;
+  if (!variations::GetVariationParams(kFieldTrialName, &variation_params))
+    return;
+
+  // Order matches WorkerPoolType above.
+  static const char* kWorkerPoolNames[] = {
+    "Background",
+    "BackgroundFileIO",
+    "Foreground",
+    "ForegroundFileIO",
+  };
+  static_assert(arraysize(kWorkerPoolNames) == WORKER_POOL_COUNT,

[fdoray, 2016/08/05 22:59:12]

What do you think of this?

struct SchedulerWorkerPoolPredefinedParams {
  const char* name,
  ThreadPriority priority_hint,
  IORestriction io_restriction
};

std::vector<SchedulerWorkerPoolPredefinedParams> predefined_params_vector;

DCHECK_EQ(predefined_params_vector.size(), BACKGROUND_WORKER_POOL);
predefined_params_vector.emplace_back(
  "Background",
  ThreadPriority::BACKGROUND,
  IORestriction::DISALLOWED);
...

for (const auto& predefined_params : predefined_params_vector) {
  // Get extra params from |variation_params|.
  // Add SchedulerWorkerPoolParams to |params_vector|.
}

I like that the name and the priority hint/io restriction are together + I'm
pretty sure that it will require less lines of code.

[robliao, 2016/08/05 23:45:38]

Went one further and just used a static const struct array.

+                "Mismatched Worker Pool Types and Names");
+
+  std::vector<WorkerPoolVariationValues> values;
+  for (size_t i = 0; i < arraysize(kWorkerPoolNames); i++) {

[fdoray, 2016/08/05 22:59:12]

for (const char* worker_pool_name : kWorkerPoolNames)

[robliao, 2016/08/05 23:45:38]

Done.

+    const char* current = kWorkerPoolNames[i];
+    const auto pair = variation_params.find(current);
+    if (pair == variation_params.end()) {
+      LOG(WARNING) << "Missing Worker Pool Configuration: " << current;
+      return;
+    }
+
+    const WorkerPoolVariationValues variation_value =
+        StringToWorkerPoolVariationValues(pair->second);
+
+    if (variation_value.threads == 0 ||
+        variation_value.detach_period.is_zero()) {
+      LOG(WARNING) << "Invalid Worker Pool Configuration: " << current <<
+          " [" << pair->second << "]";
+      return;
+    }
+
+    values.push_back(variation_value);
+  }
+
+  DCHECK_EQ(values.size(), WORKER_POOL_COUNT);
+
+  using ThreadPriority = base::ThreadPriority;
+  using IORestriction = base::SchedulerWorkerPoolParams::IORestriction;
+  std::vector<base::SchedulerWorkerPoolParams> params_vector;
+  DCHECK_EQ(params_vector.size(), BACKGROUND_WORKER_POOL);
+  params_vector.emplace_back(
+      kWorkerPoolNames[BACKGROUND_WORKER_POOL],
+      ThreadPriority::BACKGROUND,
+      IORestriction::DISALLOWED,
+      values[BACKGROUND_WORKER_POOL].threads,
+      values[BACKGROUND_WORKER_POOL].detach_period);
+
+  DCHECK_EQ(params_vector.size(), BACKGROUND_FILE_IO_WORKER_POOL);
+  params_vector.emplace_back(
+      kWorkerPoolNames[BACKGROUND_FILE_IO_WORKER_POOL],
+      ThreadPriority::BACKGROUND,
+      IORestriction::ALLOWED,
+      values[BACKGROUND_FILE_IO_WORKER_POOL].threads,
+      values[BACKGROUND_FILE_IO_WORKER_POOL].detach_period);
+
+  DCHECK_EQ(params_vector.size(), FOREGROUND_WORKER_POOL);
+  params_vector.emplace_back(
+      kWorkerPoolNames[FOREGROUND_WORKER_POOL],
+      ThreadPriority::NORMAL,
+      IORestriction::DISALLOWED,
+      values[FOREGROUND_WORKER_POOL].threads,
+      values[FOREGROUND_WORKER_POOL].detach_period);
+
+  DCHECK_EQ(params_vector.size(), FOREGROUND_FILE_IO_WORKER_POOL);
+  params_vector.emplace_back(
+      kWorkerPoolNames[FOREGROUND_FILE_IO_WORKER_POOL],
+      ThreadPriority::NORMAL,
+      IORestriction::ALLOWED,
+      values[FOREGROUND_FILE_IO_WORKER_POOL].threads,
+      values[FOREGROUND_FILE_IO_WORKER_POOL].detach_period);
+
+  DCHECK_EQ(params_vector.size(), WORKER_POOL_COUNT);
+
+  base::TaskScheduler::CreateAndSetDefaultTaskScheduler(
+      params_vector, base::Bind(WorkerPoolIndexForTraits));
+}
+
 // Returns the new local state object, guaranteed non-NULL.
 // |local_state_task_runner| must be a shutdown-blocking task runner.
 PrefService* InitializeLocalState(
     base::SequencedTaskRunner* local_state_task_runner,
     const base::CommandLine& parsed_command_line) {
   TRACE_EVENT0("startup", "ChromeBrowserMainParts::InitializeLocalState")
 
   // Load local state.  This includes the application locale so we know which
   // locale dll to load.  This also causes local state prefs to be registered.
   PrefService* local_state = g_browser_process->local_state();
@@ skipping 877 matching lines @@
   chromeos::CrosSettings::Initialize();
 #endif  // defined(OS_CHROMEOS)
 
   SetupOriginTrialsCommandLine();
 
   // Now the command line has been mutated based on about:flags, we can setup
   // metrics and initialize field trials. The field trials are needed by
   // IOThread's initialization which happens in BrowserProcess:PreCreateThreads.
   SetupMetricsAndFieldTrials();
 
+  MaybeInitializeTaskScheduler();
+
   // ChromeOS needs ResourceBundle::InitSharedInstance to be called before this.
   browser_process_->PreCreateThreads();
 
   device::GeolocationProvider::SetGeolocationDelegate(
       new ChromeGeolocationDelegate());
 
   return content::RESULT_CODE_NORMAL_EXIT;
 }
 
 void ChromeBrowserMainParts::PreMainMessageLoopRun() {
@@ skipping 841 matching lines @@
   chromeos::CrosSettings::Shutdown();
 #endif  // defined(OS_CHROMEOS)
 #endif  // defined(OS_ANDROID)
 }
 
 // Public members:
 
 void ChromeBrowserMainParts::AddParts(ChromeBrowserMainExtraParts* parts) {
   chrome_extra_parts_.push_back(parts);
 }