components/visitedlink/test/visitedlink_perftest.cc

   1 // Copyright (c) 2010 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 <algorithm>
   6 #include <string>
   7 #include <vector>
   8
   9 #include "base/file_util.h"
  10 #include "base/files/file_path.h"
  11 #include "base/memory/shared_memory.h"
  12 #include "base/strings/stringprintf.h"
  13 #include "base/test/perftimer.h"
  14 #include "base/test/test_file_util.h"
  15 #include "components/visitedlink/browser/visitedlink_master.h"
  16 #include "testing/gtest/include/gtest/gtest.h"
  17 #include "url/gurl.h"
  18
  19 using base::TimeDelta;
  20
  21 namespace visitedlink {
  22
  23 namespace {
  24
  25 // how we generate URLs, note that the two strings should be the same length
  26 const int add_count = 10000;
  27 const int load_test_add_count = 250000;
  28 const char added_prefix[] = "http://www.google.com/stuff/something/foo?session=85025602345625&id=1345142319023&seq=";
  29 const char unadded_prefix[] = "http://www.google.org/stuff/something/foo?session=39586739476365&id=2347624314402&seq=";
  30
  31 // Returns a URL with the given prefix and index
  32 GURL TestURL(const char* prefix, int i) {
  33   return GURL(base::StringPrintf("%s%d", prefix, i));
  34 }
  35
  36 // We have no slaves, so all methods on this listener are a no-ops.
  37 class DummyVisitedLinkEventListener : public VisitedLinkMaster::Listener {
  38  public:
  39   DummyVisitedLinkEventListener() {}
  40   virtual void NewTable(base::SharedMemory* table) OVERRIDE {}
  41   virtual void Add(VisitedLinkCommon::Fingerprint) OVERRIDE {}
  42   virtual void Reset() OVERRIDE {}
  43 };
  44
  45
  46 // this checks IsVisited for the URLs starting with the given prefix and
  47 // within the given range
  48 void CheckVisited(VisitedLinkMaster& master, const char* prefix,
  49                   int begin, int end) {
  50   for (int i = begin; i < end; i++)
  51     master.IsVisited(TestURL(prefix, i));
  52 }
  53
  54 // Fills that master's table with URLs starting with the given prefix and
  55 // within the given range
  56 void FillTable(VisitedLinkMaster& master, const char* prefix,
  57                int begin, int end) {
  58   for (int i = begin; i < end; i++)
  59     master.AddURL(TestURL(prefix, i));
  60 }
  61
  62 class VisitedLink : public testing::Test {
  63  protected:
  64   base::FilePath db_path_;
  65   virtual void SetUp() {
  66     ASSERT_TRUE(file_util::CreateTemporaryFile(&db_path_));
  67   }
  68   virtual void TearDown() {
  69     base::DeleteFile(db_path_, false);
  70   }
  71 };
  72
  73 } // namespace
  74
  75 // This test tests adding many things to a database, and how long it takes
  76 // to query the database with different numbers of things in it. The time
  77 // is the total time to do all the operations, and as such, it is only
  78 // useful for a regression test. If there is a regression, it might be
  79 // useful to make another set of tests to test these things in isolation.
  80 TEST_F(VisitedLink, TestAddAndQuery) {
  81   // init
  82   VisitedLinkMaster master(new DummyVisitedLinkEventListener(),
  83                            NULL, true, true, db_path_, 0);
  84   ASSERT_TRUE(master.Init());
  85
  86   PerfTimeLogger timer("Visited_link_add_and_query");
  87
  88   // first check without anything in the table
  89   CheckVisited(master, added_prefix, 0, add_count);
  90
  91   // now fill half the table
  92   const int half_size = add_count / 2;
  93   FillTable(master, added_prefix, 0, half_size);
  94
  95   // check the table again, half of these URLs will be visited, the other half
  96   // will not
  97   CheckVisited(master, added_prefix, 0, add_count);
  98
  99   // fill the rest of the table
 100   FillTable(master, added_prefix, half_size, add_count);
 101
 102   // check URLs, doing half visited, half unvisited
 103   CheckVisited(master, added_prefix, 0, add_count);
 104   CheckVisited(master, unadded_prefix, 0, add_count);
 105 }
 106
 107 // Tests how long it takes to write and read a large database to and from disk.
 108 TEST_F(VisitedLink, TestLoad) {
 109   // create a big DB
 110   {
 111     PerfTimeLogger table_initialization_timer("Table_initialization");
 112
 113     VisitedLinkMaster master(new DummyVisitedLinkEventListener(),
 114                              NULL, true, true, db_path_, 0);
 115
 116     // time init with empty table
 117     PerfTimeLogger initTimer("Empty_visited_link_init");
 118     bool success = master.Init();
 119     initTimer.Done();
 120     ASSERT_TRUE(success);
 121
 122     // add a bunch of stuff
 123     // TODO(maruel): This is very inefficient because the file gets rewritten
 124     // many time and this is the actual bottleneck of this test. The file should
 125     // only get written that the end of the FillTable call, not 4169(!) times.
 126     FillTable(master, added_prefix, 0, load_test_add_count);
 127
 128     // time writing the file out out
 129     PerfTimeLogger flushTimer("Visited_link_database_flush");
 130     master.RewriteFile();
 131     // TODO(maruel): Without calling FlushFileBuffers(master.file_); you don't
 132     // know really how much time it took to write the file.
 133     flushTimer.Done();
 134
 135     table_initialization_timer.Done();
 136   }
 137
 138   // test loading the DB back, we do this several times since the flushing is
 139   // not very reliable.
 140   const int load_count = 5;
 141   std::vector<double> cold_load_times;
 142   std::vector<double> hot_load_times;
 143   for (int i = 0; i < load_count; i++) {
 144     // make sure the file has to be re-loaded
 145     file_util::EvictFileFromSystemCache(db_path_);
 146
 147     // cold load (no OS cache, hopefully)
 148     {
 149       PerfTimer cold_timer;
 150
 151       VisitedLinkMaster master(new DummyVisitedLinkEventListener(),
 152                                NULL,
 153                                true,
 154                                true,
 155                                db_path_,
 156                                0);
 157       bool success = master.Init();
 158       TimeDelta elapsed = cold_timer.Elapsed();
 159       ASSERT_TRUE(success);
 160
 161       cold_load_times.push_back(elapsed.InMillisecondsF());
 162     }
 163
 164     // hot load (with OS caching the file in memory)
 165     {
 166       PerfTimer hot_timer;
 167
 168       VisitedLinkMaster master(new DummyVisitedLinkEventListener(),
 169                                NULL,
 170                                true,
 171                                true,
 172                                db_path_,
 173                                0);
 174       bool success = master.Init();
 175       TimeDelta elapsed = hot_timer.Elapsed();
 176       ASSERT_TRUE(success);
 177
 178       hot_load_times.push_back(elapsed.InMillisecondsF());
 179     }
 180   }
 181
 182   // We discard the max and return the average time.
 183   cold_load_times.erase(std::max_element(cold_load_times.begin(),
 184                                          cold_load_times.end()));
 185   hot_load_times.erase(std::max_element(hot_load_times.begin(),
 186                                         hot_load_times.end()));
 187
 188   double cold_sum = 0, hot_sum = 0;
 189   for (int i = 0; i < static_cast<int>(cold_load_times.size()); i++) {
 190     cold_sum += cold_load_times[i];
 191     hot_sum += hot_load_times[i];
 192   }
 193   LogPerfResult("Visited_link_cold_load_time",
 194                 cold_sum / cold_load_times.size(), "ms");
 195   LogPerfResult("Visited_link_hot_load_time",
 196                 hot_sum / hot_load_times.size(), "ms");
 197 }
 198
 199 }  // namespace visitedlink