1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include <string> 6 7 #include "base/basictypes.h" 8 #include "base/bind.h" 9 #include "base/bind_helpers.h" 10 #include "base/hash.h" 11 #include "base/strings/string_util.h" 12 #include "base/test/perf_time_logger.h" 13 #include "base/test/test_file_util.h" 14 #include "base/threading/thread.h" 15 #include "base/timer/timer.h" 16 #include "net/base/cache_type.h" 17 #include "net/base/io_buffer.h" 18 #include "net/base/net_errors.h" 19 #include "net/base/test_completion_callback.h" 20 #include "net/disk_cache/backend_impl.h" 21 #include "net/disk_cache/block_files.h" 22 #include "net/disk_cache/disk_cache.h" 23 #include "net/disk_cache/disk_cache_test_base.h" 24 #include "net/disk_cache/disk_cache_test_util.h" 25 #include "testing/gtest/include/gtest/gtest.h" 26 #include "testing/platform_test.h" 27 28 using base::Time; 29 30 namespace { 31 32 struct TestEntry { 33 std::string key; 34 int data_len; 35 }; 36 typedef std::vector<TestEntry> TestEntries; 37 38 const int kMaxSize = 16 * 1024 - 1; 39 40 // Creates num_entries on the cache, and writes 200 bytes of metadata and up 41 // to kMaxSize of data to each entry. 42 bool TimeWrite(int num_entries, disk_cache::Backend* cache, 43 TestEntries* entries) { 44 const int kSize1 = 200; 45 scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize1)); 46 scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kMaxSize)); 47 48 CacheTestFillBuffer(buffer1->data(), kSize1, false); 49 CacheTestFillBuffer(buffer2->data(), kMaxSize, false); 50 51 int expected = 0; 52 53 MessageLoopHelper helper; 54 CallbackTest callback(&helper, true); 55 56 base::PerfTimeLogger timer("Write disk cache entries"); 57 58 for (int i = 0; i < num_entries; i++) { 59 TestEntry entry; 60 entry.key = GenerateKey(true); 61 entry.data_len = rand() % kMaxSize; 62 entries->push_back(entry); 63 64 disk_cache::Entry* cache_entry; 65 net::TestCompletionCallback cb; 66 int rv = cache->CreateEntry(entry.key, &cache_entry, cb.callback()); 67 if (net::OK != cb.GetResult(rv)) 68 break; 69 int ret = cache_entry->WriteData( 70 0, 0, buffer1.get(), kSize1, 71 base::Bind(&CallbackTest::Run, base::Unretained(&callback)), false); 72 if (net::ERR_IO_PENDING == ret) 73 expected++; 74 else if (kSize1 != ret) 75 break; 76 77 ret = cache_entry->WriteData( 78 1, 0, buffer2.get(), entry.data_len, 79 base::Bind(&CallbackTest::Run, base::Unretained(&callback)), false); 80 if (net::ERR_IO_PENDING == ret) 81 expected++; 82 else if (entry.data_len != ret) 83 break; 84 cache_entry->Close(); 85 } 86 87 helper.WaitUntilCacheIoFinished(expected); 88 timer.Done(); 89 90 return (expected == helper.callbacks_called()); 91 } 92 93 // Reads the data and metadata from each entry listed on |entries|. 94 bool TimeRead(int num_entries, disk_cache::Backend* cache, 95 const TestEntries& entries, bool cold) { 96 const int kSize1 = 200; 97 scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize1)); 98 scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kMaxSize)); 99 100 CacheTestFillBuffer(buffer1->data(), kSize1, false); 101 CacheTestFillBuffer(buffer2->data(), kMaxSize, false); 102 103 int expected = 0; 104 105 MessageLoopHelper helper; 106 CallbackTest callback(&helper, true); 107 108 const char* message = cold ? "Read disk cache entries (cold)" : 109 "Read disk cache entries (warm)"; 110 base::PerfTimeLogger timer(message); 111 112 for (int i = 0; i < num_entries; i++) { 113 disk_cache::Entry* cache_entry; 114 net::TestCompletionCallback cb; 115 int rv = cache->OpenEntry(entries[i].key, &cache_entry, cb.callback()); 116 if (net::OK != cb.GetResult(rv)) 117 break; 118 int ret = cache_entry->ReadData( 119 0, 0, buffer1.get(), kSize1, 120 base::Bind(&CallbackTest::Run, base::Unretained(&callback))); 121 if (net::ERR_IO_PENDING == ret) 122 expected++; 123 else if (kSize1 != ret) 124 break; 125 126 ret = cache_entry->ReadData( 127 1, 0, buffer2.get(), entries[i].data_len, 128 base::Bind(&CallbackTest::Run, base::Unretained(&callback))); 129 if (net::ERR_IO_PENDING == ret) 130 expected++; 131 else if (entries[i].data_len != ret) 132 break; 133 cache_entry->Close(); 134 } 135 136 helper.WaitUntilCacheIoFinished(expected); 137 timer.Done(); 138 139 return (expected == helper.callbacks_called()); 140 } 141 142 int BlockSize() { 143 // We can use form 1 to 4 blocks. 144 return (rand() & 0x3) + 1; 145 } 146 147 } // namespace 148 149 TEST_F(DiskCacheTest, Hash) { 150 int seed = static_cast<int>(Time::Now().ToInternalValue()); 151 srand(seed); 152 153 base::PerfTimeLogger timer("Hash disk cache keys"); 154 for (int i = 0; i < 300000; i++) { 155 std::string key = GenerateKey(true); 156 base::Hash(key); 157 } 158 timer.Done(); 159 } 160 161 TEST_F(DiskCacheTest, CacheBackendPerformance) { 162 base::Thread cache_thread("CacheThread"); 163 ASSERT_TRUE(cache_thread.StartWithOptions( 164 base::Thread::Options(base::MessageLoop::TYPE_IO, 0))); 165 166 ASSERT_TRUE(CleanupCacheDir()); 167 net::TestCompletionCallback cb; 168 scoped_ptr<disk_cache::Backend> cache; 169 int rv = disk_cache::CreateCacheBackend( 170 net::DISK_CACHE, net::CACHE_BACKEND_BLOCKFILE, cache_path_, 0, false, 171 cache_thread.message_loop_proxy().get(), NULL, &cache, cb.callback()); 172 173 ASSERT_EQ(net::OK, cb.GetResult(rv)); 174 175 int seed = static_cast<int>(Time::Now().ToInternalValue()); 176 srand(seed); 177 178 TestEntries entries; 179 int num_entries = 1000; 180 181 EXPECT_TRUE(TimeWrite(num_entries, cache.get(), &entries)); 182 183 base::MessageLoop::current()->RunUntilIdle(); 184 cache.reset(); 185 186 ASSERT_TRUE(file_util::EvictFileFromSystemCache( 187 cache_path_.AppendASCII("index"))); 188 ASSERT_TRUE(file_util::EvictFileFromSystemCache( 189 cache_path_.AppendASCII("data_0"))); 190 ASSERT_TRUE(file_util::EvictFileFromSystemCache( 191 cache_path_.AppendASCII("data_1"))); 192 ASSERT_TRUE(file_util::EvictFileFromSystemCache( 193 cache_path_.AppendASCII("data_2"))); 194 ASSERT_TRUE(file_util::EvictFileFromSystemCache( 195 cache_path_.AppendASCII("data_3"))); 196 197 rv = disk_cache::CreateCacheBackend( 198 net::DISK_CACHE, net::CACHE_BACKEND_BLOCKFILE, cache_path_, 0, false, 199 cache_thread.message_loop_proxy().get(), NULL, &cache, cb.callback()); 200 ASSERT_EQ(net::OK, cb.GetResult(rv)); 201 202 EXPECT_TRUE(TimeRead(num_entries, cache.get(), entries, true)); 203 204 EXPECT_TRUE(TimeRead(num_entries, cache.get(), entries, false)); 205 206 base::MessageLoop::current()->RunUntilIdle(); 207 } 208 209 // Creating and deleting "entries" on a block-file is something quite frequent 210 // (after all, almost everything is stored on block files). The operation is 211 // almost free when the file is empty, but can be expensive if the file gets 212 // fragmented, or if we have multiple files. This test measures that scenario, 213 // by using multiple, highly fragmented files. 214 TEST_F(DiskCacheTest, BlockFilesPerformance) { 215 ASSERT_TRUE(CleanupCacheDir()); 216 217 disk_cache::BlockFiles files(cache_path_); 218 ASSERT_TRUE(files.Init(true)); 219 220 int seed = static_cast<int>(Time::Now().ToInternalValue()); 221 srand(seed); 222 223 const int kNumEntries = 60000; 224 disk_cache::Addr* address = new disk_cache::Addr[kNumEntries]; 225 226 base::PerfTimeLogger timer1("Fill three block-files"); 227 228 // Fill up the 32-byte block file (use three files). 229 for (int i = 0; i < kNumEntries; i++) { 230 EXPECT_TRUE(files.CreateBlock(disk_cache::RANKINGS, BlockSize(), 231 &address[i])); 232 } 233 234 timer1.Done(); 235 base::PerfTimeLogger timer2("Create and delete blocks"); 236 237 for (int i = 0; i < 200000; i++) { 238 int entry = rand() * (kNumEntries / RAND_MAX + 1); 239 if (entry >= kNumEntries) 240 entry = 0; 241 242 files.DeleteBlock(address[entry], false); 243 EXPECT_TRUE(files.CreateBlock(disk_cache::RANKINGS, BlockSize(), 244 &address[entry])); 245 } 246 247 timer2.Done(); 248 base::MessageLoop::current()->RunUntilIdle(); 249 delete[] address; 250 } 251
