Disk cache perf test: guard linux only flushes, add fd limit control.

net/disk_cache/disk_cache_perftest.cc

 // Copyright (c) 2011 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 <limits>
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_path.h"
 #include "base/hash.h"
+#include "base/process/process_metrics.h"
 #include "base/strings/string_util.h"
 #include "base/test/perf_time_logger.h"
 #include "base/test/test_file_util.h"
 #include "base/threading/thread.h"
 #include "net/base/cache_type.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
 #include "net/disk_cache/blockfile/backend_impl.h"
 #include "net/disk_cache/blockfile/block_files.h"
 #include "net/disk_cache/disk_cache.h"
 #include "net/disk_cache/disk_cache_test_base.h"
 #include "net/disk_cache/disk_cache_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 
 using base::Time;
 
 namespace {
 
+size_t MaybeGetMaxFds() {
+#if defined(OS_POSIX)
+  return base::GetMaxFds();
+#else
+  return std::numeric_limits<size_t>::max();
+#endif
+}
+
+void MaybeSetFdLimit(unsigned int max_descriptors) {
+#if defined(OS_POSIX)
+  base::SetFdLimit(max_descriptors);
+#endif
+}
+
 struct TestEntry {
   std::string key;
   int data_len;
 };
 
 class DiskCachePerfTest : public DiskCacheTestWithCache {
+ public:
+  DiskCachePerfTest() : saved_fd_limit_(MaybeGetMaxFds()) {
+    if (saved_fd_limit_ < kFdLimitForCacheTests)
+      MaybeSetFdLimit(kFdLimitForCacheTests);
+  }
+
+  ~DiskCachePerfTest() override {
+    if (saved_fd_limit_ < kFdLimitForCacheTests)
+      MaybeSetFdLimit(kFdLimitForCacheTests);
+  }
+
  protected:
   enum class WhatToRead {
     HEADERS_ONLY,
     HEADERS_AND_BODY,
   };
 
   // Helper methods for constructing tests.
   bool TimeWrite();
   bool TimeRead(WhatToRead what_to_read, const char* timer_message);
   void ResetAndEvictSystemDiskCache();
 
   // Complete perf tests.
   void CacheBackendPerformance();
 
+  const size_t kFdLimitForCacheTests = 8192;
+
   const int kNumEntries = 1000;
   const int kHeadersSize = 200;
   const int kBodySize = 16 * 1024 - 1;
 
   std::vector<TestEntry> entries_;
+
+ private:
+  const size_t saved_fd_limit_;
 };
 
 // Creates num_entries on the cache, and writes 200 bytes of metadata and up
 // to kBodySize of data to each entry.
 bool DiskCachePerfTest::TimeWrite() {
   scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kHeadersSize));
   scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kBodySize));
 
   CacheTestFillBuffer(buffer1->data(), kHeadersSize, false);
   CacheTestFillBuffer(buffer2->data(), kBodySize, false);
@@ skipping 106 matching lines @@
   cache_.reset();
 
   // Flush all files in the cache out of system memory.
   const base::FilePath::StringType file_pattern = FILE_PATH_LITERAL("*");
   base::FileEnumerator enumerator(cache_path_, true /* recursive */,
                                   base::FileEnumerator::FILES, file_pattern);
   for (base::FilePath file_path = enumerator.Next(); !file_path.empty();
        file_path = enumerator.Next()) {
     ASSERT_TRUE(base::EvictFileFromSystemCache(file_path));
   }
-  // And, cache directories.
+#if defined(OS_LINUX)
+  // And, cache directories, on platforms where the eviction utility supports
+  // this (currently Linux only).
   if (simple_cache_mode_) {
     ASSERT_TRUE(
         base::EvictFileFromSystemCache(cache_path_.AppendASCII("index-dir")));
   }
   ASSERT_TRUE(base::EvictFileFromSystemCache(cache_path_));
+#endif
 
   DisableFirstCleanup();
   InitCache();
 }
 
 void DiskCachePerfTest::CacheBackendPerformance() {
   InitCache();
   EXPECT_TRUE(TimeWrite());
 
   ResetAndEvictSystemDiskCache();
@@ skipping 61 matching lines @@
     files.DeleteBlock(address[entry], false);
     EXPECT_TRUE(
         files.CreateBlock(disk_cache::RANKINGS, BlockSize(), &address[entry]));
   }
 
   timer2.Done();
   base::MessageLoop::current()->RunUntilIdle();
 }
 
 }  // namespace