Re-enable pre-read experiment as a finch field trial.

chrome/app/client_util.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 <windows.h>
 #include <shlwapi.h>
 
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/environment.h"
 #include "base/file_version_info.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/rand_util.h"  // For PreRead experiment.
+#include "base/sha1.h"  // For PreRead experiment.
 #include "base/strings/string16.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/version.h"
 #include "base/win/windows_version.h"
 #include "chrome/app/breakpad_win.h"
 #include "chrome/app/client_util.h"
 #include "chrome/app/image_pre_reader_win.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_result_codes.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/env_vars.h"
 #include "chrome/installer/util/browser_distribution.h"
 #include "chrome/installer/util/channel_info.h"
 #include "chrome/installer/util/google_update_constants.h"
 #include "chrome/installer/util/google_update_settings.h"
 #include "chrome/installer/util/install_util.h"
 #include "chrome/installer/util/util_constants.h"
 
 namespace {
 // The entry point signature of chrome.dll.
 typedef int (*DLL_MAIN)(HINSTANCE, sandbox::SandboxInterfaceInfo*);
 
 typedef void (*RelaunchChromeBrowserWithNewCommandLineIfNeededFunc)();
 
+// Returns true if the build date for this module precedes the expiry date
+// for the pre-read experiment.
+bool PreReadExperimentIsActive() {
+  const int kPreReadExpiryYear = 2014;
+  const int kPreReadExpiryMonth = 7;
+  const int kPreReadExpiryDay = 1;
+  const char kBuildTimeStr[] = __DATE__ " " __TIME__;
+
+  // Get the timestamp of the build.
+  base::Time build_time;
+  bool result = base::Time::FromString(kBuildTimeStr, &build_time);
+  DCHECK(result);
+
+  // Get the timestamp at which the experiment expires.
+  base::Time::Exploded exploded = {0};
+  exploded.year = kPreReadExpiryYear;
+  exploded.month = kPreReadExpiryMonth;
+  exploded.day_of_month = kPreReadExpiryDay;
+  base::Time expiration_time = base::Time::FromLocalExploded(exploded);
+
+  // Return true if the build time predates the expiration time..
+  return build_time < expiration_time;
+}
+
+// Get random unit values, i.e., in the range (0, 1), denoting a die-toss for
+// being in an experiment population and experimental group thereof.
+void GetPreReadPopulationAndGroup(double* population, double* group) {
+  DCHECK(population != NULL);

[rvargas (doing something else), 2013/09/05 22:18:48]

nit: we usually don't dcheck on required arguments being not null.

[Roger McFarlane (Chromium), 2013/09/11 20:42:54]

Done.

+  DCHECK(group != NULL);
+
+  // By default we use the metrics id for the user as stable pseudo-random
+  // input to a hash.
+  base::string16 metrics_id;
+  GoogleUpdateSettings::GetMetricsId(&metrics_id);
+
+  // If this user has not metrics id, we fall back to a purely random value
+  // per browser session.
+  const size_t kLength = 16;
+  std::string random_value(metrics_id.empty() ? base::RandBytesAsString(kLength)
+                                              : base::WideToUTF8(metrics_id));
+
+  // To interpret the value as a random number we hash it and read the first 8
+  // bytes of the hash as a unit-interval representing a die-toss for being in
+  // the experiment population and the second 8 bytes as a die-toss for being
+  // in various experiment groups.
+  unsigned char sha1_hash[base::kSHA1Length];
+  base::SHA1HashBytes(
+      reinterpret_cast<const unsigned char*>(random_value.c_str()),
+      random_value.size() * sizeof(random_value[0]),
+      sha1_hash);
+  COMPILE_ASSERT(2 * sizeof(uint64) < sizeof(sha1_hash), need_more_data);
+  const uint64* random_bits = reinterpret_cast<uint64*>(&sha1_hash[0]);
+
+  // Convert the bits into unit-intervals and return.
+  *population = base::BitsToOpenEndedUnitInterval(random_bits[0]);
+  *group = base::BitsToOpenEndedUnitInterval(random_bits[1]);
+}
+
+// Gets the amount of pre-read to use as well as the experiment group in which
+// the user falls.
+size_t InitPreReadPercentage() {
+  // By default use the old behaviour: read 100%.
+  const uint8 kDefaultPercentage = 100;

[rvargas (doing something else), 2013/09/05 22:18:48]

nit: being just a number, this should be a plain int as opposed to unsigned with
specific length.

[Roger McFarlane (Chromium), 2013/09/11 20:42:54]

Done.

+  const char kDefaultFormatStr[] = "%d-pct-default";
+  const char kControlFormatStr[] = "%d-pct-control";
+  const char kGroupFormatStr[] = "%d-pct";
+
+  COMPILE_ASSERT(kDefaultPercentage <= 100, default_percentage_too_large);
+  COMPILE_ASSERT(kDefaultPercentage % 5 == 0, default_percentage_not_mult_5);
+
+  // Roll the dice to determine if this user is in the experiment and if so,
+  // in which experimental group.
+  double population = 0.0;
+  double group = 0.0;
+  GetPreReadPopulationAndGroup(&population, &group);
+
+    // We limit experiment populations to 1% of the Stable and 10% of each of

[rvargas (doing something else), 2013/09/05 22:18:48]

nit: indentation

[Roger McFarlane (Chromium), 2013/09/11 20:42:54]

Done.

+  // the other channels.
+  const string16 channel(GoogleUpdateSettings::GetChromeChannel(
+      GoogleUpdateSettings::IsSystemInstall()));
+  double threshold = (channel == installer::kChromeChannelStable) ? 0.01 : 0.10;
+
+  // If the experiment has expired use the default pre-read level. Otherwise,
+  // those not in the experiment population also use the default pre-read level.
+  size_t value = kDefaultPercentage;
+  const char* format_str = kDefaultFormatStr;
+  if (PreReadExperimentIsActive() && (population <= threshold)) {
+    // We divide the experiment population into groups pre-reading at 5 percent
+    // increments. This is 21 groups of 5 -- to include the range [100, 105) --

[rvargas (doing something else), 2013/09/05 22:18:48]

nit: I think it is more clear if you say that value is [0, 100] and multiple of
5. 105 is misleading

[Roger McFarlane (Chromium), 2013/09/11 20:42:54]

Done.

+    // rounded down to the nearest 5.
+    value = static_cast<size_t>(group * 21.0) * 5;
+    DCHECK_LE(value, 100u);
+    DCHECK_EQ(0u, value % 5);
+    format_str =
+        (value == kDefaultPercentage) ? kControlFormatStr : kGroupFormatStr;
+  }
+
+  // Generate the group name corresponding to this percentage value.
+  std::string group_name;
+  base::SStringPrintf(&group_name, format_str, value);
+
+  // Persiste the group name to the environment so that it can be used for

[cpu_(ooo_6.6-7.5), 2013/09/05 20:21:16]

Persist 

[Roger McFarlane (Chromium), 2013/09/11 20:42:54]

Done.

+  // reporting.
+  scoped_ptr<base::Environment> env(base::Environment::Create());
+  env->SetVar(chrome::kPreReadEnvironmentVariable, group_name);
+
+  // Return the percentage value to be used.
+  return value;
+}
+
 // Expects that |dir| has a trailing backslash. |dir| is modified so it
 // contains the full path that was tried. Caller must check for the return
 // value not being null to determine if this path contains a valid dll.
 HMODULE LoadChromeWithDirectory(string16* dir) {
   ::SetCurrentDirectoryW(dir->c_str());
   const CommandLine& cmd_line = *CommandLine::ForCurrentProcess();
 #if !defined(CHROME_MULTIPLE_DLL)
   const wchar_t* dll_name = installer::kChromeDll;
 #else
   const wchar_t* dll_name = cmd_line.HasSwitch(switches::kProcessType) ?
       installer::kChromeChildDll : installer::kChromeDll;
 #endif
   dir->append(dll_name);
 
 #if !defined(WIN_DISABLE_PREREAD)
   // On Win7 with Syzygy, pre-read is a win. There've very little difference
   // between 25% and 100%. For cold starts, with or without prefetch 25%
   // performs slightly better than 100%. On XP, pre-read is generally a

[rvargas (doing something else), 2013/09/05 22:18:48]

I'm curious as to why it looks like we use preread on XP while knowing that it
is a loss.

[Roger McFarlane (Chromium), 2013/09/11 20:42:54]

My bad, as a pre-experiment, I reverted the value to a constant (100) from (ver
> XP ? 25 : 0) and didn't update the comment appropriately.

We've seen differing data points between experiments in the lab and histograms
in the wild. In the lab, pre-read on XP seems to always be a net loss.
Histograms from previous experiments (as well as what happened when we turned
pre-read off recently) is that in aggregate we get worse performance with it
off.

That's a part of the motivation for this experiment being run again.

   // performance loss.
   if (!cmd_line.HasSwitch(switches::kProcessType)) {
     const size_t kStepSize = 1024 * 1024;
-    // Pre-read 100% of the binary. This was the fallback behaviour for an
-    // expired pre-read experiment as well as the standard behaviour before
-    // the pre-read experiment. Performance regressed when the experiment
-    // (and fallback to 100%) was removed. See http://crbug/245435
-    // TODO(rogerm): Revive the pre-read experiment under finch.
-    uint8 percent = 100;
-    ImagePreReader::PartialPreReadImage(dir->c_str(), percent, kStepSize);
+    size_t percentage = InitPreReadPercentage();
+    ImagePreReader::PartialPreReadImage(dir->c_str(), percentage, kStepSize);
   }
 #endif
 
   return ::LoadLibraryExW(dir->c_str(), NULL,
                           LOAD_WITH_ALTERED_SEARCH_PATH);
 }
 
 void RecordDidRun(const string16& dll_path) {
   bool system_level = !InstallUtil::IsPerUserInstall(dll_path.c_str());
   GoogleUpdateSettings::UpdateDidRunState(true, system_level);
@@ skipping 165 matching lines @@
   }
 };
 
 MainDllLoader* MakeMainDllLoader() {
 #if defined(GOOGLE_CHROME_BUILD)
   return new ChromeDllLoader();
 #else
   return new ChromiumDllLoader();
 #endif
 }