net/disk_cache/simple: Reduce size of EntrySet nodes.

net/disk_cache/simple/simple_index_file_unittest.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 "base/hash.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/pickle.h"
 #include "base/stringprintf.h"
 #include "base/time.h"
@@ skipping 34 matching lines @@
   EXPECT_EQ(new_index_metadata.GetNumberOfEntries(),
             index_metadata.GetNumberOfEntries());
   EXPECT_EQ(new_index_metadata.cache_size_, index_metadata.cache_size_);
 
   EXPECT_TRUE(new_index_metadata.CheckIndexMetadata());
 }
 
 class SimpleIndexFileTest : public testing::Test {
  public:
   bool CompareTwoEntryMetadata(const EntryMetadata& a, const EntryMetadata& b) {
-    return a.hash_key_ == b.hash_key_ &&
-        a.last_used_time_ == b.last_used_time_ &&
-        a.entry_size_ == b.entry_size_;
+    return a.last_used_time_ == b.last_used_time_ &&
+           a.entry_size_ == b.entry_size_;
   }
 
 };
 
 TEST_F(SimpleIndexFileTest, Serialize) {
   SimpleIndex::EntrySet entries;
-  EntryMetadata entries_array[] = {
-    EntryMetadata(11, Time::FromInternalValue(22), 33),
-    EntryMetadata(22, Time::FromInternalValue(33), 44),
-    EntryMetadata(33, Time::FromInternalValue(44), 55)
-  };
-  SimpleIndexFile::IndexMetadata index_metadata(arraysize(entries_array), 456);
-  for (uint32 i = 0; i < arraysize(entries_array); ++i) {
-    SimpleIndex::InsertInEntrySet(entries_array[i], &entries);
+  static const uint64 kHashes[] = { 11, 22, 33 };

[gavinp, 2013/05/17 14:54:17]

I don't think the static here is helpful.

[digit1, 2013/05/17 15:07:33]

Without static, this actually creates a temporary array in the stack and
initializes it by storing each value individually there (I just re-checked that
on my workstation by disassembling the code).

Unfortunately, the compiler isn't very smart with constant local arrays. It does
better with integers though. Granted that's only a unit test, but good to know.

[gavinp, 2013/05/17 15:37:45]

Wow, interesting.

What a mess compilers are; I know certainly that objects with constructors are
scary when static and const, and actually cheaper as automatics. So now, thanks
to your investigation, I don't know anything, and I have to disassemble
anything. Thanks, I think....

+  static const size_t kNumHashes = arraysize(kHashes);
+  EntryMetadata metadata_entries[kNumHashes];
+
+  SimpleIndexFile::IndexMetadata index_metadata(static_cast<uint64>(kNumHashes),
+                                                456);
+  for (size_t i = 0; i < kNumHashes; ++i) {
+    uint64 hash = kHashes[i];
+    metadata_entries[i] =
+        EntryMetadata(Time::FromInternalValue(hash), hash);
+    SimpleIndex::InsertInEntrySet(hash, metadata_entries[i], &entries);
   }
 
   scoped_ptr<Pickle> pickle = SimpleIndexFile::Serialize(
       index_metadata, entries);
   EXPECT_TRUE(pickle.get() != NULL);
 
   scoped_ptr<SimpleIndex::EntrySet> new_entries = SimpleIndexFile::Deserialize(
       reinterpret_cast<const char*>(pickle->data()),
       pickle->size());
   EXPECT_TRUE(new_entries.get() != NULL);
   EXPECT_EQ(entries.size(), new_entries->size());
 
-  for (uint32 i = 0; i < arraysize(entries_array); ++i) {
-    SimpleIndex::EntrySet::iterator it =
-        new_entries->find(entries_array[i].GetHashKey());
+  for (size_t i = 0; i < kNumHashes; ++i) {
+    SimpleIndex::EntrySet::iterator it = new_entries->find(kHashes[i]);
     EXPECT_TRUE(new_entries->end() != it);
-    EXPECT_TRUE(CompareTwoEntryMetadata(it->second, entries_array[i]));
+    EXPECT_TRUE(CompareTwoEntryMetadata(it->second, metadata_entries[i]));
   }
 }
 
 }