Add a PartialPreReadImage function to file_util (on Windows).

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_util.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/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "base/version.h"
 #include "base/win/registry.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/installer/util/browser_distribution.h"
 #include "chrome/installer/util/channel_info.h"
 #include "chrome/installer/util/install_util.h"
 #include "chrome/installer/util/google_update_constants.h"
 #include "chrome/installer/util/google_update_settings.h"
 #include "chrome/installer/util/util_constants.h"
 
@@ skipping 144 matching lines @@
   // but by default it is enabled in release builds. The ability to disable it
   // is useful for evaluating competing optimization techniques.
   if (!cmd_line.HasSwitch(switches::kProcessType)) {
     // The kernel brings in 8 pages for the code section at a time and 4 pages
     // for other sections. We can skip over these pages to avoid a soft page
     // fault which may not occur during code execution. However skipping 4K at
     // a time still has better performance over 32K and 16K according to data.
     // TODO(ananta): Investigate this and tune.
     const size_t kStepSize = 4 * 1024;
 
+    // We hypothesize that pre-reading only the bytes actually touched during
+    // startup should improve startup time. The Syzygy toolchain attempts to
+    // optimize the binary layout of chrome.dll, rearranging the code and data
+    // blocks such that temporally related blocks (i.e., code and data used in
+    // startup, browser, renderer, etc) are grouped together, and that blocks
+    // used early in the process lifecycle occur earlier in their sections.
+    // Our most recent results in the lab show that around 20% of code and 30%
+    // of data is touched during startup. The value below is an experiment
+    // to see what happens to startup time when we read just a percentage
+    // of each section of the binary versus reading the entire thing.
+    // TODO(rogerm): Investigate/validate this and (if benefical) automate
+    //     the process of determining how much to read from each section
+    //     and embed that info somewhere.
+    const DWORD kPreReadPercentage = 25;
+
     DWORD pre_read_size = 0;
+    DWORD pre_read_percentage = kPreReadPercentage;
     DWORD pre_read_step_size = kStepSize;
     DWORD pre_read = 1;
+    bool use_registry = false;
 
     // TODO(chrisha): This path should not be ChromeFrame specific, and it
     //     should not be hard-coded with 'Google' in the path. Rather, it should
     //     use the product name.
     base::win::RegKey key(HKEY_CURRENT_USER, L"Software\\Google\\ChromeFrame",
                           KEY_QUERY_VALUE);
     if (key.Valid()) {
+
       key.ReadValueDW(L"PreReadSize", &pre_read_size);
+      key.ReadValueDW(L"PreReadPercentage", &pre_read_percentage);

[chrisha, 2012/02/03 16:31:08]

ubernit: Keep these in alphabetic order?

[Roger McFarlane (Chromium), 2012/02/03 17:45:42]

Done. Also only read the sizes and percentage if there's a PreRead value.

       key.ReadValueDW(L"PreReadStepSize", &pre_read_step_size);
-      key.ReadValueDW(L"PreRead", &pre_read);
+      use_registry = (key.ReadValueDW(L"PreRead", &pre_read) == ERROR_SUCCESS);
       key.Close();
     }
 
 #if defined(OS_WIN)
 #if defined(GOOGLE_CHROME_BUILD)
     // The PreRead experiment is unable to use the standard FieldTrial
     // mechanism as pre-reading happens in chrome.exe prior to loading
     // chrome.dll. As such, we use a custom approach. If the experiment is
     // running (not expired, and we're running a version of chrome from an
     // appropriate channel) then we look to the registry for the BreakPad/UMA
     // metricsid. We use this to seed a coin-toss, which is then communicated
     // to chrome.dll via an environment variable, which indicates to chrome.dll
     // that the experiment is running, causing it to report sub-histogram
     // results.
-
+    //
+    // If we've read pre-read settings from the registry, then someone has
+    // specificaly set their pre-read options and is not participating in

[Sigurður Ásgeirsson, 2012/02/03 16:36:39]

nit: specificaly->specifically

[Roger McFarlane (Chromium), 2012/02/03 17:45:42]

Done.

+    // the experiment.
+    //
     // If the experiment is running, indicate it to chrome.dll via an
-    // environment variable.
-    if (GetPreReadExperimentGroup(&pre_read)) {
+    // environment variable. A pre_read value of 1 indicates that a full
+    // (100%, the current default behaviour) pre-read is to be performed,
+    // while a pre_read value of 0 indicates a partial pre-read is to be
+    // performed, up to the configured percentage.
+    if (!use_registry && GetPreReadExperimentGroup(&pre_read)) {
       DCHECK(pre_read == 0 || pre_read == 1);
       scoped_ptr<base::Environment> env(base::Environment::Create());
       env->SetVar(chrome::kPreReadEnvironmentVariable,
                   pre_read ? "1" : "0");
+      pre_read_percentage = kPreReadPercentage;
     }
 #endif  // if defined(GOOGLE_CHROME_BUILD)
 #endif  // if defined(OS_WIN)
 
-    if (pre_read) {
-      TRACE_EVENT_BEGIN_ETW("PreReadImage", 0, "");
-      file_util::PreReadImage(dir->c_str(), pre_read_size, pre_read_step_size);
-      TRACE_EVENT_END_ETW("PreReadImage", 0, "");
-    }
+    // Clamp the DWORD percentage to fit into a uint8 that's <= 100.
+    uint8 percentage_to_read = static_cast<uint8>(
+        std::min<DWORD>(pre_read ? 100 : pre_read_percentage, 100) & 0xFF);

[chrisha, 2012/02/03 16:31:08]

The & 0xFF is redundant at this point, given the clamping to <= 100.

[Roger McFarlane (Chromium), 2012/02/03 17:45:42]

Done.

+
+    // Perform the full or partial pre-read.
+    TRACE_EVENT_BEGIN_ETW("PreReadImage", 0, "");
+    ImagePreReader::PartialPreReadImage(dir->c_str(),
+                                        percentage_to_read,
+                                        pre_read_step_size);
+    TRACE_EVENT_END_ETW("PreReadImage", 0, "");

[chrisha, 2012/02/03 16:31:08]

Leave this surrounded by the "if (pre_read && percentage_to_read > 0)"?

[Roger McFarlane (Chromium), 2012/02/03 17:45:42]

So that's not quite the way the experiment works now. We're comparing
pre-reading everthing (the status quo) with performing a partial pre-read.

pre-read == 1:
  status_quo, the expression above selects 100 as the percentage
pre-read == 0:
   partial, the expression selects the partial pre-read percentage.

   }
 #endif  // NDEBUG
 #endif  // WIN_DISABLE_PREREAD
 
   return ::LoadLibraryExW(dir->c_str(), NULL,
                           LOAD_WITH_ALTERED_SEARCH_PATH);
 }
 
 void RecordDidRun(const std::wstring& dll_path) {
   bool system_level = !InstallUtil::IsPerUserInstall(dll_path.c_str());
@@ skipping 152 matching lines @@
   }
 };
 
 MainDllLoader* MakeMainDllLoader() {
 #if defined(GOOGLE_CHROME_BUILD)
   return new ChromeDllLoader();
 #else
   return new ChromiumDllLoader();
 #endif
 }