page cycler: Use buffer-cache priming code on all systems.

chrome/test/page_cycler/page_cycler_test.cc

 // Copyright (c) 2006-2009 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 "base/basictypes.h"
 #include "base/command_line.h"
-#include "base/eintr_wrapper.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "base/process_util.h"
 #include "base/string_util.h"
 #include "chrome/browser/net/url_fixer_upper.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/test/automation/tab_proxy.h"
 #include "chrome/test/automation/window_proxy.h"
 #include "chrome/test/chrome_process_util.h"
 #include "chrome/test/ui/ui_test.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/net_util.h"
 
 #if defined(OS_MACOSX)
-#include <errno.h>
-#include <fcntl.h>
 #include <string.h>
 #include <sys/resource.h>
 #endif
 
 #ifndef NDEBUG
 #define TEST_ITERATIONS 2
 #define DATABASE_TEST_ITERATIONS 2
 #else
 #define TEST_ITERATIONS 10
 // For some unknown reason, the DB perf tests are much much slower on the
@@ skipping 32 matching lines @@
     } else {
       limits.rlim_cur = std::min(max_descriptors, limits.rlim_max);
     }
     if (setrlimit(RLIMIT_NOFILE, &limits) != 0) {
       PLOG(ERROR) << "Failed to set file descriptor limit";
     }
   } else {
     PLOG(ERROR) << "Failed to get file descriptor limit";
   }
 }
+#endif  // OS_MACOSX
 
-void PopulateUBC(const FilePath &test_dir) {
-  // This will recursively walk the directory given and read all the files it
-  // finds.  This is done so the Mac UBC is likely to have as much loaded as
-  // possible.  Without this, the tests of this build gets one set of timings
-  // and then the reference build test, gets slightly faster ones (even if the
-  // reference build is the same binary).  The hope is by forcing all the
-  // possible data into the UBC we equalize the tests for comparing timing data.
+void PopulateBufferCache(const FilePath& test_dir) {
+  // This will recursively walk the directory given and read all the
+  // files it finds.  This is done so the system file cache is likely
+  // to have as much loaded as possible.  Without this, the tests of
+  // this build gets one set of timings and then the reference build
+  // test, gets slightly faster ones (even if the reference build is
+  // the same binary).  The hope is by forcing all the possible data
+  // into the cache we equalize the tests for comparing timing data.
 
   // We don't want to walk into .svn dirs, so we have to do the tree walk
   // ourselves.
 
   std::vector<FilePath> dirs;
   dirs.push_back(test_dir);
   const FilePath svn_dir(FILE_PATH_LITERAL(".svn"));
 
   for (size_t idx = 0; idx < dirs.size(); ++idx) {
     file_util::FileEnumerator dir_enumerator(dirs[idx], false,
                                       file_util::FileEnumerator::DIRECTORIES);
     FilePath path;
     for (path = dir_enumerator.Next();
          !path.empty();
          path = dir_enumerator.Next()) {
       if (path.BaseName() != svn_dir)
         dirs.push_back(path);
     }
   }
 
-  char buf[1024];
   unsigned int loaded = 0;
 
   // We seem to have some files in the data dirs that are just there for
   // reference, make a quick attempt to skip them by matching suffixes.
   std::vector<FilePath::StringType> ignore_suffixes;
   ignore_suffixes.push_back(FILE_PATH_LITERAL(".orig.html"));
   ignore_suffixes.push_back(FILE_PATH_LITERAL(".html-original"));
 
   std::vector<FilePath>::const_iterator iter;
   for (iter = dirs.begin(); iter != dirs.end(); ++iter) {
@@ skipping 16 matching lines @@
         if ((base_name_size > suffix.size()) &&
             (base_name.value().compare(base_name_size - suffix.size(),
                                        suffix.size(), suffix) == 0)) {
           should_skip = true;
           break;
         }
       }
       if (should_skip)
         continue;
 
-      // Read the file to get it into the UBC
-      int fd = open(path.value().c_str(), O_RDONLY);
-      if (fd >= 0) {
+      // Read the file fully to get it into the cache.
+      // We don't care what the contents are.
+      if (file_util::ReadFileToString(path, NULL))
         ++loaded;
-        while (HANDLE_EINTR(read(fd, buf, sizeof(buf))) > 0) {
-        }
-        HANDLE_EINTR(close(fd));
-      }
     }
   }
-  LOG(INFO) << "UBC should be loaded with " << loaded << " files.";
+  LOG(INFO) << "Buffer cache should be primed with " << loaded << " files.";
 }
-#endif  // defined(OS_MACOSX)
 
 class PageCyclerTest : public UITest {
  protected:
   bool print_times_only_;
 #if defined(OS_MACOSX)
   rlim_t fd_limit_;
 #endif
  public:
   PageCyclerTest()
       : print_times_only_(false) {
@@ skipping 34 matching lines @@
     return TEST_ITERATIONS;
   }
 
   // For HTTP tests, the name must be safe for use in a URL without escaping.
   void RunPageCycler(const char* name, std::wstring* pages,
                      std::string* timings, bool use_http) {
     FilePath test_path = GetDataPath(name);
     ASSERT_TRUE(file_util::DirectoryExists(test_path))
         << "Missing test directory " << test_path.value();
 
-#if defined(OS_MACOSX)
-    PopulateUBC(test_path);
-#endif
+    PopulateBufferCache(test_path);
 
     GURL test_url;
     if (use_http) {
       test_url = GURL(std::string(kBaseUrl) + name + "/start.html");
     } else {
       test_path = test_path.Append(FILE_PATH_LITERAL("start.html"));
       test_url = net::FilePathToFileURL(test_path);
     }
 
     // run N iterations
@@ skipping 266 matching lines @@
 PAGE_CYCLER_DATABASE_TESTS("insert-transactions",
                            InsertTransactions);
 PAGE_CYCLER_DATABASE_TESTS("update-transactions",
                            UpdateTransactions);
 PAGE_CYCLER_DATABASE_TESTS("delete-transactions",
                            DeleteTransactions);
 PAGE_CYCLER_DATABASE_TESTS("pseudo-random-transactions",
                            PseudoRandomTransactions);
 
 }  // namespace