google_hash 0.8.1 → 0.8.2

data/ext/sparsehash-2.0.2/src/stamp-h1

@@ -0,0 +1 @@
+timestamp for src/config.h

data/ext/sparsehash-2.0.2/src/template_util_unittest.cc

@@ -0,0 +1,134 @@
+// Copyright 2005 Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// ----
+//
+// These tests are really compile time tests.
+// If you try to step through this in a debugger
+// you will not see any evaluations, merely that
+// value is assigned true or false sequentially.
+
+#include <sparsehash/internal/sparseconfig.h>
+#include <config.h>
+#include <sparsehash/template_util.h>
+
+#include "testutil.h"
+
+using namespace GOOGLE_NAMESPACE;
+
+namespace {
+
+TEST(TemplateUtilTest, TestSize) {
+  EXPECT_GT(sizeof(GOOGLE_NAMESPACE::big_), sizeof(GOOGLE_NAMESPACE::small_));
+}
+
+TEST(TemplateUtilTest, TestIntegralConstants) {
+  // test the built-in types.
+  EXPECT_TRUE(true_type::value);
+  EXPECT_FALSE(false_type::value);
+
+  typedef integral_constant<int, 1> one_type;
+  EXPECT_EQ(1, one_type::value);
+}
+
+TEST(TemplateUtilTest, TestTemplateIf) {
+  typedef if_<true, true_type, false_type>::type if_true;
+  EXPECT_TRUE(if_true::value);
+
+  typedef if_<false, true_type, false_type>::type if_false;
+  EXPECT_FALSE(if_false::value);
+}
+
+TEST(TemplateUtilTest, TestTemplateTypeEquals) {
+  // Check that the TemplateTypeEquals works correctly.
+  bool value = false;
+
+  // Test the same type is true.
+  value = type_equals_<int, int>::value;
+  EXPECT_TRUE(value);
+
+  // Test different types are false.
+  value = type_equals_<float, int>::value;
+  EXPECT_FALSE(value);
+
+  // Test type aliasing.
+  typedef const int foo;
+  value = type_equals_<const foo, const int>::value;
+  EXPECT_TRUE(value);
+}
+
+TEST(TemplateUtilTest, TestTemplateAndOr) {
+  // Check that the TemplateTypeEquals works correctly.
+  bool value = false;
+
+  // Yes && Yes == true.
+  value = and_<true_, true_>::value;
+  EXPECT_TRUE(value);
+  // Yes && No == false.
+  value = and_<true_, false_>::value;
+  EXPECT_FALSE(value);
+  // No && Yes == false.
+  value = and_<false_, true_>::value;
+  EXPECT_FALSE(value);
+  // No && No == false.
+  value = and_<false_, false_>::value;
+  EXPECT_FALSE(value);
+
+  // Yes || Yes == true.
+  value = or_<true_, true_>::value;
+  EXPECT_TRUE(value);
+  // Yes || No == true.
+  value = or_<true_, false_>::value;
+  EXPECT_TRUE(value);
+  // No || Yes == true.
+  value = or_<false_, true_>::value;
+  EXPECT_TRUE(value);
+  // No || No == false.
+  value = or_<false_, false_>::value;
+  EXPECT_FALSE(value);
+}
+
+TEST(TemplateUtilTest, TestIdentity) {
+  EXPECT_TRUE(
+      (type_equals_<GOOGLE_NAMESPACE::identity_<int>::type, int>::value));
+  EXPECT_TRUE(
+      (type_equals_<GOOGLE_NAMESPACE::identity_<void>::type, void>::value));
+}
+
+}  // namespace
+
+#include <iostream>
+
+int main(int, char **) {
+  // All the work is done in the static constructors.  If they don't
+  // die, the tests have all passed.
+  std::cout << "PASS\n";
+  return 0;
+}
+

data/ext/{sparsehash-1.8.1 → sparsehash-2.0.2}/src/testutil.h

@@ -28,7 +28,6 @@
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 // ---
-// Author: Craig Silverstein
 
 // This macro mimics a unittest framework, but is a bit less flexible
 // than most.  It requires a superclass to derive from, and does all
@@ -38,8 +37,11 @@
 #ifndef SPARSEHASH_TEST_UTIL_H_
 #define SPARSEHASH_TEST_UTIL_H_
 
+#include <sparsehash/internal/sparseconfig.h>
 #include "config.h"
 #include <stdio.h>
+#include <stdlib.h>    // for exit
+#include <stdexcept>   // for length_error
 
 _START_GOOGLE_NAMESPACE_
 
@@ -54,11 +56,20 @@ namespace testing {
 
 #define EXPECT_FALSE(a)  EXPECT_TRUE(!(a))
 #define EXPECT_EQ(a, b)  EXPECT_TRUE((a) == (b))
+#define EXPECT_NE(a, b)  EXPECT_TRUE((a) != (b))
 #define EXPECT_LT(a, b)  EXPECT_TRUE((a) < (b))
 #define EXPECT_GT(a, b)  EXPECT_TRUE((a) > (b))
 #define EXPECT_LE(a, b)  EXPECT_TRUE((a) <= (b))
 #define EXPECT_GE(a, b)  EXPECT_TRUE((a) >= (b))
 
+#define EXPECT_DEATH(cmd, expected_error_string)                          \
+  try {                                                                   \
+    cmd;                                                                  \
+    EXPECT_FALSE("did not see expected error: " #expected_error_string);  \
+  } catch (const std::length_error&) {                                    \
+    /* Good, the cmd failed. */                                           \
+  }
+
 #define TEST(suitename, testname)                                       \
   class TEST_##suitename##_##testname {                                 \
    public:                                                              \
@@ -244,6 +255,10 @@ template<typename C1, typename C2, typename C3, typename C4, typename C5,
   template<class TypeParam>                                             \
   void TEST_onetype_##superclass##_##testname<TypeParam>::Run()
 
+// This is a dummy class just to make converting from internal-google
+// to opensourcing easier.
+class Test { };
+
 } // namespace testing
 
 _END_GOOGLE_NAMESPACE_

data/ext/{sparsehash-1.8.1 → sparsehash-2.0.2}/src/time_hash_map.cc

@@ -1,6 +1,6 @@
 // Copyright (c) 2005, Google Inc.
 // All rights reserved.
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
@@ -14,7 +14,7 @@
 //     * Neither the name of Google Inc. nor the names of its
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
-// 
+//
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
@@ -29,9 +29,21 @@
 
 // ---
 // Authors: Sanjay Ghemawat and Craig Silverstein
-//
+
 // Time various hash map implementations
 //
+// Below, times are per-call.  "Memory use" is "bytes in use by
+// application" as reported by tcmalloc, compared before and after the
+// function call.  This does not really report fragmentation, which is
+// not bad for the sparse* routines but bad for the dense* ones.
+//
+// The tests generally yield best-case performance because the
+// code uses sequential keys; on the other hand, "map_fetch_random" does
+// lookups in a pseudorandom order.  Also, "stresshashfunction" is
+// a stress test of sorts.  It uses keys from an arithmetic sequence, which,
+// if combined with a quick-and-dirty hash function, will yield worse
+// performance than the otherwise similar "map_predict/grow."
+//
 // Consider doing the following to get good numbers:
 //
 // 1. Run the tests on a machine with no X service. Make sure no other
@@ -42,24 +54,25 @@
 //
 // See PERFORMANCE for the output of one example run.
 
-#include "config.h"
+#include <sparsehash/internal/sparseconfig.h>
+#include <config.h>
+#ifdef HAVE_INTTYPES_H
+# include <inttypes.h>
+#endif         // for uintptr_t
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 extern "C" {
 #include <time.h>
 #ifdef HAVE_SYS_TIME_H
-#include <sys/time.h>
+# include <sys/time.h>
 #endif
 #ifdef HAVE_SYS_RESOURCE_H
-#include <sys/resource.h>
+# include <sys/resource.h>
 #endif
 #ifdef HAVE_SYS_UTSNAME_H
-#include <sys/utsname.h>      // for uname()
-#endif
-#ifdef HAVE_WINDOWS_H
-#include <Windows.h>          // for GetTickCount()
-#endif
+# include <sys/utsname.h>
+#endif      // for uname()
 }
 
 // The functions that we call on each map, that differ for different types.
@@ -67,14 +80,17 @@ extern "C" {
 
 #include <map>
 #include HASH_MAP_H
-#include <google/type_traits.h>
-
-#include <google/sparse_hash_map>
-using GOOGLE_NAMESPACE::sparse_hash_map;
-
-#include <google/dense_hash_map>
+#include <algorithm>
+#include <vector>
+#include <sparsehash/type_traits.h>
+#include <sparsehash/dense_hash_map>
+#include <sparsehash/sparse_hash_map>
+
+using std::map;
+using std::swap;
+using std::vector;
 using GOOGLE_NAMESPACE::dense_hash_map;
-
+using GOOGLE_NAMESPACE::sparse_hash_map;
 
 static bool FLAGS_test_sparse_hash_map = true;
 static bool FLAGS_test_dense_hash_map = true;
@@ -82,57 +98,85 @@ static bool FLAGS_test_hash_map = true;
 static bool FLAGS_test_map = true;
 
 static bool FLAGS_test_4_bytes = true;
+static bool FLAGS_test_8_bytes = true;
 static bool FLAGS_test_16_bytes = true;
 static bool FLAGS_test_256_bytes = true;
 
+#if defined(HAVE_UNORDERED_MAP)
+using HASH_NAMESPACE::unordered_map;
+#elif defined(HAVE_HASH_MAP) || defined(_MSC_VER)
+using HASH_NAMESPACE::hash_map;
+#endif
+
 static const int kDefaultIters = 10000000;
 
-// Normally I don't like non-const references, but using them here ensures
-// the inlined code ends up as efficient as possible.
+// A version of each of the hashtable classes we test, that has been
+// augumented to provide a common interface.  For instance, the
+// sparse_hash_map and dense_hash_map versions set empty-key and
+// deleted-key (we can do this because all our tests use int-like
+// keys), so the users don't have to.  The hash_map version adds
+// resize(), so users can just call resize() for all tests without
+// worrying about whether the map-type supports it or not.
 
-// These are operations that are supported on some hash impls but not others
-template<class MapType> inline void SET_DELETED_KEY(MapType&, int /*key*/) {}
-template<class MapType> inline void SET_EMPTY_KEY(MapType&, int /*key*/) {}
-template<class MapType> inline void RESIZE(MapType&, int /*iters*/) {}
+template<typename K, typename V, typename H>
+class EasyUseSparseHashMap : public sparse_hash_map<K,V,H> {
+ public:
+  EasyUseSparseHashMap() {
+    this->set_deleted_key(-1);
+  }
+};
 
-template<class K, class V, class H, class E, class A>
-inline void SET_DELETED_KEY(sparse_hash_map<K,V,H,E,A>& m, int key) {
-  m.set_deleted_key(key);
-}
-template<class K, class V, class H, class E, class A>
-inline void SET_DELETED_KEY(dense_hash_map<K,V,H,E,A>& m, int key) {
-  m.set_deleted_key(key);
-}
+template<typename K, typename V, typename H>
+class EasyUseDenseHashMap : public dense_hash_map<K,V,H> {
+ public:
+  EasyUseDenseHashMap() {
+    this->set_empty_key(-1);
+    this->set_deleted_key(-2);
+  }
+};
 
-template<class K, class V, class H, class E, class A>
-inline void SET_EMPTY_KEY(dense_hash_map<K,V,H,E,A>& m, int key) {
-  m.set_empty_key(key);
-}
+// For pointers, we only set the empty key.
+template<typename K, typename V, typename H>
+class EasyUseSparseHashMap<K*, V, H> : public sparse_hash_map<K*,V,H> {
+ public:
+  EasyUseSparseHashMap() { }
+};
+
+template<typename K, typename V, typename H>
+class EasyUseDenseHashMap<K*, V, H> : public dense_hash_map<K*,V,H> {
+ public:
+  EasyUseDenseHashMap() {
+    this->set_empty_key((K*)(~0));
+  }
+};
 
-template<class K, class V, class H, class E, class A>
-inline void RESIZE(sparse_hash_map<K,V,H,E,A>& m, int iters) {
-  m.resize(iters);
-}
-template<class K, class V, class H, class E, class A>
-inline void RESIZE(dense_hash_map<K,V,H,E,A>& m, int iters) {
-  m.resize(iters);
-}
 #if defined(HAVE_UNORDERED_MAP)
-template<class K, class V, class H, class E, class A>
-inline void RESIZE(HASH_NAMESPACE::unordered_map<K,V,H,E,A>& m, int iters) {
-  m.rehash(iters);   // the tr1 name for resize()
-}
+template<typename K, typename V, typename H>
+class EasyUseHashMap : public unordered_map<K,V,H> {
+ public:
+  // resize() is called rehash() in tr1
+  void resize(size_t r) { this->rehash(r); }
+};
 #elif defined(_MSC_VER)
-// MSVC/Dinkumware hash impl has fewer template args, and no resize support.
-template<class K, class V, class H, class A>
-inline void RESIZE(HASH_NAMESPACE::hash_map<K,V,H,A>& m, int iters) {
-}
+template<typename K, typename V, typename H>
+class EasyUseHashMap : public hash_map<K,V,H> {
+ public:
+  void resize(size_t r) { }
+};
 #elif defined(HAVE_HASH_MAP)
-template<class K, class V, class H, class E, class A>
-inline void RESIZE(HASH_NAMESPACE::hash_map<K,V,H,E,A>& m, int iters) {
-  m.resize(iters);
-}
-#endif  // HAVE_HASH_MAP
+template<typename K, typename V, typename H>
+class EasyUseHashMap : public hash_map<K,V,H> {
+ public:
+  // Don't need to do anything: hash_map is already easy to use!
+};
+#endif
+
+template<typename K, typename V>
+class EasyUseMap : public map<K,V> {
+ public:
+  void resize(size_t) { }   // map<> doesn't support resize
+};
+
 
 // Returns the number of hashes that have been done since the last
 // call to NumHashesSinceLastCall().  This is shared across all
@@ -181,7 +225,7 @@ template<int Size, int Hashsize> class HashObject {
     for (size_t i = 0; i < Hashsize - sizeof(i_); ++i) {
       hashval += buffer_[i];
     }
-    return SPARSEHASH_HASH<int>()(hashval);   // defined in sparseconfig.h
+    return SPARSEHASH_HASH<int>()(hashval);
   }
 
   bool operator==(const class_type& that) const { return this->i_ == that.i_; }
@@ -220,15 +264,17 @@ template<> class HashObject<sizeof(int), sizeof(int)> {
   int i_;        // the key used for hashing
 };
 
+_START_GOOGLE_NAMESPACE_
+
 // Let the hashtable implementations know it can use an optimized memcpy,
 // because the compiler defines both the destructor and copy constructor.
 
-_START_GOOGLE_NAMESPACE_
 template<int Size, int Hashsize>
 struct has_trivial_copy< HashObject<Size, Hashsize> > : true_type { };
 
 template<int Size, int Hashsize>
 struct has_trivial_destructor< HashObject<Size, Hashsize> > : true_type { };
+
 _END_GOOGLE_NAMESPACE_
 
 class HashFn {
@@ -237,12 +283,23 @@ class HashFn {
   size_t operator()(const HashObject<Size,Hashsize>& obj) const {
     return obj.Hash();
   }
-  // For windows
+  // Do the identity hash for pointers.
+  template<int Size, int Hashsize>
+  size_t operator()(const HashObject<Size,Hashsize>* obj) const {
+    return reinterpret_cast<uintptr_t>(obj);
+  }
+
+  // Less operator for MSVC's hash containers.
   template<int Size, int Hashsize>
   bool operator()(const HashObject<Size,Hashsize>& a,
                   const HashObject<Size,Hashsize>& b) const {
     return a < b;
   }
+  template<int Size, int Hashsize>
+  bool operator()(const HashObject<Size,Hashsize>* a,
+                  const HashObject<Size,Hashsize>* b) const {
+    return a < b;
+  }
   // These two public members are required by msvc.  4 and 8 are defaults.
   static const size_t bucket_size = 4;
   static const size_t min_buckets = 8;
@@ -260,7 +317,7 @@ class Rusage {
   /* Reset collection */
   void Reset();
 
-  /* Show usage */
+  /* Show usage, in seconds */
   double UserTime();
 
  private:
@@ -303,7 +360,6 @@ inline double Rusage::UserTime() {
 #endif
 }
 
-
 static void print_uname() {
 #ifdef HAVE_SYS_UTSNAME_H
   struct utsname u;
@@ -326,9 +382,11 @@ static void stamp_run(int iters) {
   printf("Current time (GMT): %s", asctime(gmtime(&now)));
 }
 
-// If you have google-perftools (http://code.google.com/p/google-perftools),
-// then you can figure out how much memory these implementations use
-// as well.
+// This depends on the malloc implementation for exactly what it does
+// -- and thus requires work after the fact to make sense of the
+// numbers -- and also is likely thrown off by the memory management
+// STL tries to do on its own.
+
 #ifdef HAVE_GOOGLE_MALLOC_EXTENSION_H
 #include <google/malloc_extension.h>
 
@@ -370,7 +428,6 @@ static void time_map_grow(int iters) {
   MapType set;
   Rusage t;
 
-  SET_EMPTY_KEY(set, -2);
   const size_t start = CurrentMemoryUsage();
   t.Reset();
   for (int i = 0; i < iters; i++) {
@@ -386,9 +443,8 @@ static void time_map_grow_predicted(int iters) {
   MapType set;
   Rusage t;
 
-  SET_EMPTY_KEY(set, -2);
   const size_t start = CurrentMemoryUsage();
-  RESIZE(set, iters);
+  set.resize(iters);
   t.Reset();
   for (int i = 0; i < iters; i++) {
     set[i] = i+1;
@@ -404,7 +460,6 @@ static void time_map_replace(int iters) {
   Rusage t;
   int i;
 
-  SET_EMPTY_KEY(set, -2);
   for (i = 0; i < iters; i++) {
     set[i] = i+1;
   }
@@ -419,13 +474,13 @@ static void time_map_replace(int iters) {
 }
 
 template<class MapType>
-static void time_map_fetch(int iters) {
+static void time_map_fetch(int iters, const vector<int>& indices,
+                           char const* title) {
   MapType set;
   Rusage t;
   int r;
   int i;
 
-  SET_EMPTY_KEY(set, -2);
   for (i = 0; i < iters; i++) {
     set[i] = i+1;
   }
@@ -433,12 +488,39 @@ static void time_map_fetch(int iters) {
   r = 1;
   t.Reset();
   for (i = 0; i < iters; i++) {
-    r ^= static_cast<int>(set.find(i) != set.end());
+    r ^= static_cast<int>(set.find(indices[i]) != set.end());
   }
   double ut = t.UserTime();
 
   srand(r);   // keep compiler from optimizing away r (we never call rand())
-  report("map_fetch", ut, iters, 0, 0);
+  report(title, ut, iters, 0, 0);
+}
+
+template<class MapType>
+static void time_map_fetch_sequential(int iters) {
+  vector<int> v(iters);
+  for (int i = 0; i < iters; i++) {
+    v[i] = i;
+  }
+  time_map_fetch<MapType>(iters, v, "map_fetch_sequential");
+}
+
+// Apply a pseudorandom permutation to the given vector.
+static void shuffle(vector<int>* v) {
+  srand(9);
+  for (int n = v->size(); n >= 2; n--) {
+    swap((*v)[n - 1], (*v)[static_cast<unsigned>(rand()) % n]);
+  }
+}
+
+template<class MapType>
+static void time_map_fetch_random(int iters) {
+  vector<int> v(iters);
+  for (int i = 0; i < iters; i++) {
+    v[i] = i;
+  }
+  shuffle(&v);
+  time_map_fetch<MapType>(iters, v, "map_fetch_random");
 }
 
 template<class MapType>
@@ -448,7 +530,6 @@ static void time_map_fetch_empty(int iters) {
   int r;
   int i;
 
-  SET_EMPTY_KEY(set, -2);
   r = 1;
   t.Reset();
   for (i = 0; i < iters; i++) {
@@ -466,13 +547,11 @@ static void time_map_remove(int iters) {
   Rusage t;
   int i;
 
-  SET_EMPTY_KEY(set, -2);
   for (i = 0; i < iters; i++) {
     set[i] = i+1;
   }
 
   t.Reset();
-  SET_DELETED_KEY(set, -1);
   for (i = 0; i < iters; i++) {
     set.erase(i);
   }
@@ -489,8 +568,6 @@ static void time_map_toggle(int iters) {
 
   const size_t start = CurrentMemoryUsage();
   t.Reset();
-  SET_DELETED_KEY(set, -1);
-  SET_EMPTY_KEY(set, -2);
   for (i = 0; i < iters; i++) {
     set[i] = i+1;
     set.erase(i);
@@ -503,40 +580,127 @@ static void time_map_toggle(int iters) {
 }
 
 template<class MapType>
-static void measure_map(const char* label, int obj_size, int iters) {
+static void time_map_iterate(int iters) {
+  MapType set;
+  Rusage t;
+  int r;
+  int i;
+
+  for (i = 0; i < iters; i++) {
+    set[i] = i+1;
+  }
+
+  r = 1;
+  t.Reset();
+  for (typename MapType::const_iterator it = set.begin(), it_end = set.end();
+       it != it_end;
+       ++it) {
+    r ^= it->second;
+  }
+
+  double ut = t.UserTime();
+
+  srand(r);   // keep compiler from optimizing away r (we never call rand())
+  report("map_iterate", ut, iters, 0, 0);
+}
+
+template<class MapType>
+static void stresshashfunction(int desired_insertions,
+                               int map_size,
+                               int stride) {
+  Rusage t;
+  int num_insertions = 0;
+  // One measurement of user time (in seconds) is done for each iteration of
+  // the outer loop.  The times are summed.
+  double total_seconds = 0;
+  const int k = desired_insertions / map_size;
+  MapType set;
+  for (int o = 0; o < k; o++) {
+    set.clear();
+    set.resize(map_size);
+    t.Reset();
+    const int maxint = (1ull << (sizeof(int) * 8 - 1)) - 1;
+    // Use n arithmetic sequences.  Using just one may lead to overflow
+    // if stride * map_size > maxint.  Compute n by requiring
+    // stride * map_size/n < maxint, i.e., map_size/(maxint/stride) < n
+    char* key;   // something we can do math on
+    const int n = map_size / (maxint / stride) + 1;
+    for (int i = 0; i < n; i++) {
+      key = NULL;
+      key += i;
+      for (int j = 0; j < map_size/n; j++) {
+        key += stride;
+        set[reinterpret_cast<typename MapType::key_type>(key)]
+            = ++num_insertions;
+      }
+    }
+    total_seconds += t.UserTime();
+  }
+  printf("stresshashfunction map_size=%d stride=%d: %.1fns/insertion\n",
+         map_size, stride, total_seconds * 1e9 / num_insertions);
+}
+
+template<class MapType>
+static void stresshashfunction(int num_inserts) {
+  static const int kMapSizes[] = {256, 1024};
+  for (unsigned i = 0; i < sizeof(kMapSizes) / sizeof(kMapSizes[0]); i++) {
+    const int map_size = kMapSizes[i];
+    for (int stride = 1; stride <= map_size; stride *= map_size) {
+      stresshashfunction<MapType>(num_inserts, map_size, stride);
+    }
+  }
+}
+
+template<class MapType, class StressMapType>
+static void measure_map(const char* label, int obj_size, int iters,
+                        bool stress_hash_function) {
   printf("\n%s (%d byte objects, %d iterations):\n", label, obj_size, iters);
   if (1) time_map_grow<MapType>(iters);
   if (1) time_map_grow_predicted<MapType>(iters);
   if (1) time_map_replace<MapType>(iters);
-  if (1) time_map_fetch<MapType>(iters);
+  if (1) time_map_fetch_random<MapType>(iters);
+  if (1) time_map_fetch_sequential<MapType>(iters);
   if (1) time_map_fetch_empty<MapType>(iters);
   if (1) time_map_remove<MapType>(iters);
   if (1) time_map_toggle<MapType>(iters);
+  if (1) time_map_iterate<MapType>(iters);
+  // This last test is useful only if the map type uses hashing.
+  // And it's slow, so use fewer iterations.
+  if (stress_hash_function) {
+    // Blank line in the output makes clear that what follows isn't part of the
+    // table of results that we just printed.
+    puts("");
+    stresshashfunction<StressMapType>(iters / 4);
+  }
 }
 
 template<class ObjType>
 static void test_all_maps(int obj_size, int iters) {
+  const bool stress_hash_function = obj_size <= 8;
+
   if (FLAGS_test_sparse_hash_map)
-    measure_map< sparse_hash_map<ObjType, int, HashFn> >("SPARSE_HASH_MAP",
-                                                 obj_size, iters);
+    measure_map< EasyUseSparseHashMap<ObjType, int, HashFn>,
+                 EasyUseSparseHashMap<ObjType*, int, HashFn> >(
+        "SPARSE_HASH_MAP", obj_size, iters, stress_hash_function);
+
   if (FLAGS_test_dense_hash_map)
-    measure_map< dense_hash_map<ObjType, int, HashFn> >("DENSE_HASH_MAP",
-                                                obj_size, iters);
-#if defined(HAVE_UNORDERED_MAP)
-  if (FLAGS_test_hash_map)
-    measure_map< HASH_NAMESPACE::unordered_map<ObjType, int, HashFn> >(
-        "TR1 UNORDERED_MAP", obj_size, iters);
-#elif defined(HAVE_HASH_MAP)
+    measure_map< EasyUseDenseHashMap<ObjType, int, HashFn>,
+                 EasyUseDenseHashMap<ObjType*, int, HashFn> >(
+        "DENSE_HASH_MAP", obj_size, iters, stress_hash_function);
+
   if (FLAGS_test_hash_map)
-    measure_map< HASH_NAMESPACE::hash_map<ObjType, int, HashFn> >(
-        "STANDARD HASH_MAP", obj_size, iters);
-#endif
+    measure_map< EasyUseHashMap<ObjType, int, HashFn>,
+                 EasyUseHashMap<ObjType*, int, HashFn> >(
+        "STANDARD HASH_MAP", obj_size, iters, stress_hash_function);
+
   if (FLAGS_test_map)
-    measure_map< STL_NAMESPACE::map<ObjType, int, HashFn> >("STANDARD MAP",
-                                     obj_size, iters);
+    measure_map< EasyUseMap<ObjType, int>,
+                 EasyUseMap<ObjType*, int> >(
+        "STANDARD MAP", obj_size, iters, false);
 }
 
 int main(int argc, char** argv) {
+
   int iters = kDefaultIters;
   if (argc > 1) {            // first arg is # of iterations
     iters = atoi(argv[1]);
@@ -555,6 +719,7 @@ int main(int argc, char** argv) {
   // buffer.  To keep memory use similar, we normalize the number of
   // iterations based on size.
   if (FLAGS_test_4_bytes)  test_all_maps< HashObject<4,4> >(4, iters/1);
+  if (FLAGS_test_8_bytes)  test_all_maps< HashObject<8,8> >(8, iters/2);
   if (FLAGS_test_16_bytes)  test_all_maps< HashObject<16,16> >(16, iters/4);
   if (FLAGS_test_256_bytes)  test_all_maps< HashObject<256,256> >(256, iters/32);