google_hash 0.6.2 → 0.7.0

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

@@ -32,6 +32,14 @@
 //
 // Time various hash map implementations
 //
+// Consider doing the following to get good numbers:
+//
+// 1. Run the tests on a machine with no X service. Make sure no other
+//    processes are running.
+// 2. Minimize compiled-code differences. Compare results from the same
+//    binary, if possible, instead of comparing results from two different
+//    binaries.
+//
 // See PERFORMANCE for the output of one example run.
 
 #include "config.h"
@@ -68,52 +76,84 @@ using GOOGLE_NAMESPACE::sparse_hash_map;
 using GOOGLE_NAMESPACE::dense_hash_map;
 
 
+static bool FLAGS_test_sparse_hash_map = true;
+static bool FLAGS_test_dense_hash_map = true;
+static bool FLAGS_test_hash_map = true;
+static bool FLAGS_test_map = true;
+
+static bool FLAGS_test_4_bytes = true;
+static bool FLAGS_test_16_bytes = true;
+static bool FLAGS_test_256_bytes = true;
+
 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.
 
 // These are operations that are supported on some hash impls but not others
-template<class MapType> inline void SET_DELETED_KEY(MapType& m, int key) {}
-template<class MapType> inline void SET_EMPTY_KEY(MapType& m, int key) {}
-template<class MapType> inline void RESIZE(MapType& m, int iters) {}
+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<class K, class V, class H>
-inline void SET_DELETED_KEY(sparse_hash_map<K,V,H>& m, int key) {
+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>
-inline void SET_DELETED_KEY(dense_hash_map<K,V,H>& m, int 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<class K, class V, class H>
-inline void SET_EMPTY_KEY(dense_hash_map<K,V,H>& m, int key) {
+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);
 }
 
-template<class K, class V, class H>
-inline void RESIZE(sparse_hash_map<K,V,H>& m, int iters) {
+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>
-inline void RESIZE(dense_hash_map<K,V,H>& m, int 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>
-inline void RESIZE(HASH_NAMESPACE::unordered_map<K,V,H>& m, int iters) {
+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()
 }
+#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) {
+}
 #elif defined(HAVE_HASH_MAP)
-template<class K, class V, class H>
-inline void RESIZE(HASH_NAMESPACE::hash_map<K,V,H>& m, int iters) {
-#ifndef _MSC_VER    /* apparently windows hash_map doesn't support resizing */
+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  // _MSC_VER
 }
 #endif  // HAVE_HASH_MAP
 
+// Returns the number of hashes that have been done since the last
+// call to NumHashesSinceLastCall().  This is shared across all
+// HashObject instances, which isn't super-OO, but avoids two issues:
+// (1) making HashObject bigger than it ought to be (this is very
+// important for our testing), and (2) having to pass around
+// HashObject objects everywhere, which is annoying.
+static int g_num_hashes;
+static int g_num_copies;
+
+int NumHashesSinceLastCall() {
+  int retval = g_num_hashes;
+  g_num_hashes = 0;
+  return retval;
+}
+int NumCopiesSinceLastCall() {
+  int retval = g_num_copies;
+  g_num_copies = 0;
+  return retval;
+}
+
 /*
  * These are the objects we hash.  Size is the size of the object
  * (must be > sizeof(int).  Hashsize is how many of these bytes we
@@ -126,10 +166,19 @@ template<int Size, int Hashsize> class HashObject {
   HashObject(int i) : i_(i) {
     memset(buffer_, i & 255, sizeof(buffer_));   // a "random" char
   }
+  HashObject(const HashObject& that) {
+    operator=(that);
+  }
+  void operator=(const HashObject& that) {
+    g_num_copies++;
+    this->i_ = that.i_;
+    memcpy(this->buffer_, that.buffer_, sizeof(this->buffer_));
+  }
 
   size_t Hash() const {
+    g_num_hashes++;
     int hashval = i_;
-    for (int i = 0; i < Hashsize - sizeof(i_); ++i) {
+    for (size_t i = 0; i < Hashsize - sizeof(i_); ++i) {
       hashval += buffer_[i];
     }
     return SPARSEHASH_HASH<int>()(hashval);   // defined in sparseconfig.h
@@ -150,8 +199,18 @@ template<> class HashObject<sizeof(int), sizeof(int)> {
   typedef HashObject<sizeof(int), sizeof(int)> class_type;
   HashObject() {}
   HashObject(int i) : i_(i) {}
+  HashObject(const HashObject& that) {
+    operator=(that);
+  }
+  void operator=(const HashObject& that) {
+    g_num_copies++;
+    this->i_ = that.i_;
+  }
 
-  size_t Hash() const { return SPARSEHASH_HASH<int>()(i_); }
+  size_t Hash() const {
+    g_num_hashes++;
+    return SPARSEHASH_HASH<int>()(i_);
+  }
 
   bool operator==(const class_type& that) const { return this->i_ == that.i_; }
   bool operator< (const class_type& that) const { return this->i_ < that.i_; }
@@ -291,16 +350,18 @@ static size_t CurrentMemoryUsage() { return 0; }
 
 static void report(char const* title, double t,
                    int iters,
-                   size_t heap_growth) {
+                   size_t start_memory, size_t end_memory) {
   // Construct heap growth report text if applicable
-  char heap[100];
-  if (heap_growth > 0) {
-    snprintf(heap, sizeof(heap), "%8.1f MB", heap_growth / 1048576.0);
-  } else {
-    heap[0] = '\0';
+  char heap[100] = "";
+  if (end_memory > start_memory) {
+    snprintf(heap, sizeof(heap), "%7.1f MB",
+             (end_memory - start_memory) / 1048576.0);
   }
 
-  printf("%-20s %8.1f ns %s\n", title, (t * 1000000000.0 / iters), heap);
+  printf("%-20s %6.1f ns  (%8d hashes, %8d copies)%s\n",
+         title, (t * 1000000000.0 / iters),
+         NumHashesSinceLastCall(), NumCopiesSinceLastCall(),
+         heap);
   fflush(stdout);
 }
 
@@ -317,7 +378,7 @@ static void time_map_grow(int iters) {
   }
   double ut = t.UserTime();
   const size_t finish = CurrentMemoryUsage();
-  report("map_grow", ut, iters, finish - start);
+  report("map_grow", ut, iters, start, finish);
 }
 
 template<class MapType>
@@ -334,7 +395,7 @@ static void time_map_grow_predicted(int iters) {
   }
   double ut = t.UserTime();
   const size_t finish = CurrentMemoryUsage();
-  report("map_predict/grow", ut, iters, finish - start);
+  report("map_predict/grow", ut, iters, start, finish);
 }
 
 template<class MapType>
@@ -354,7 +415,7 @@ static void time_map_replace(int iters) {
   }
   double ut = t.UserTime();
 
-  report("map_replace", ut, iters, 0);
+  report("map_replace", ut, iters, 0, 0);
 }
 
 template<class MapType>
@@ -377,7 +438,7 @@ static void time_map_fetch(int iters) {
   double ut = t.UserTime();
 
   srand(r);   // keep compiler from optimizing away r (we never call rand())
-  report("map_fetch", ut, iters, 0);
+  report("map_fetch", ut, iters, 0, 0);
 }
 
 template<class MapType>
@@ -396,7 +457,7 @@ static void time_map_fetch_empty(int iters) {
   double ut = t.UserTime();
 
   srand(r);   // keep compiler from optimizing away r (we never call rand())
-  report("map_fetch_empty", ut, iters, 0);
+  report("map_fetch_empty", ut, iters, 0, 0);
 }
 
 template<class MapType>
@@ -417,7 +478,7 @@ static void time_map_remove(int iters) {
   }
   double ut = t.UserTime();
 
-  report("map_remove", ut, iters, 0);
+  report("map_remove", ut, iters, 0, 0);
 }
 
 template<class MapType>
@@ -438,12 +499,12 @@ static void time_map_toggle(int iters) {
   double ut = t.UserTime();
   const size_t finish = CurrentMemoryUsage();
 
-  report("map_toggle", ut, iters, finish - start);
+  report("map_toggle", ut, iters, start, finish);
 }
 
 template<class MapType>
-static void measure_map(const char* label, int iters) {
-  printf("\n%s:\n", label);
+static void measure_map(const char* label, int obj_size, int iters) {
+  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);
@@ -453,19 +514,34 @@ static void measure_map(const char* label, int iters) {
   if (1) time_map_toggle<MapType>(iters);
 }
 
+template<class ObjType>
+static void test_all_maps(int obj_size, int iters) {
+  if (FLAGS_test_sparse_hash_map)
+    measure_map< sparse_hash_map<ObjType, int, HashFn> >("SPARSE_HASH_MAP",
+                                                 obj_size, iters);
+  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)
+  if (FLAGS_test_hash_map)
+    measure_map< HASH_NAMESPACE::hash_map<ObjType, int, HashFn> >(
+        "STANDARD HASH_MAP", obj_size, iters);
+#endif
+  if (FLAGS_test_map)
+    measure_map< STL_NAMESPACE::map<ObjType, int, HashFn> >("STANDARD MAP",
+                                     obj_size, iters);
+}
+
 int main(int argc, char** argv) {
   int iters = kDefaultIters;
   if (argc > 1) {            // first arg is # of iterations
     iters = atoi(argv[1]);
   }
 
-  // It would be nice to set these at run-time, but by setting them at
-  // compile-time, we allow optimizations that make it as fast to use
-  // a HashObject as it would be to use just a straight int/char buffer.
-  const int obj_size = 4;
-  const int hash_size = 4;
-  typedef HashObject<obj_size, hash_size> HashObj;
-
   stamp_run(iters);
 
 #ifndef HAVE_SYS_RESOURCE_H
@@ -473,16 +549,14 @@ int main(int argc, char** argv) {
          "                 reported are wall-clock time, not user time\n");
 #endif
 
-  measure_map< sparse_hash_map<HashObj,int,HashFn> >("SPARSE_HASH_MAP", iters);
-  measure_map< dense_hash_map<HashObj,int,HashFn> >("DENSE_HASH_MAP", iters);
-#if defined(HAVE_UNORDERED_MAP)
-  measure_map< HASH_NAMESPACE::unordered_map<HashObj,int,HashFn> >(
-      "TR1 UNORDERED_MAP", iters);
-#elif defined(HAVE_HASH_MAP)
-  measure_map< HASH_NAMESPACE::hash_map<HashObj,int,HashFn> >(
-      "STANDARD HASH_MAP", iters);
-#endif
-  measure_map< STL_NAMESPACE::map<HashObj,int,HashFn> >("STANDARD MAP", iters);
+  // It would be nice to set these at run-time, but by setting them at
+  // compile-time, we allow optimizations that make it as fast to use
+  // a HashObject as it would be to use just a straight int/char
+  // 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_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);
 
   return 0;
 }

data/ext/{sparsehash-1.5.2 → sparsehash-1.8.1}/src/type_traits_unittest.cc

@@ -59,7 +59,7 @@ struct A {
 // A user-defined non-POD type with a trivial copy constructor.
 class B {
  public:
-  B(int n) : n_(n) { }
+  explicit B(int n) : n_(n) { }
  private:
   int n_;
 };
@@ -69,7 +69,7 @@ class B {
 // by specializing has_trivial_copy.
 class C {
  public:
-  C(int n) : n_(n) { }
+  explicit C(int n) : n_(n) { }
  private:
   int n_;
 };
@@ -83,7 +83,7 @@ _END_GOOGLE_NAMESPACE_
 // by specializing has_trivial_assign.
 class D {
  public:
-  D(int n) : n_(n) { }
+  explicit D(int n) : n_(n) { }
  private:
   int n_;
 };
@@ -109,7 +109,7 @@ _END_GOOGLE_NAMESPACE_
 // by specializing has_trivial_destructor.
 class F {
  public:
-  F(int n) : n_(n) { }
+  explicit F(int n) : n_(n) { }
  private:
   int n_;
 };
@@ -451,20 +451,30 @@ class TypeTraitsTest {
                             GOOGLE_NAMESPACE::remove_cv<const volatile int>::type);
   }
 
-  static void TestIsConvertible() {
-#ifndef _MSC_VER
-    ASSERT_TRUE((GOOGLE_NAMESPACE::is_convertible<int, int>::value));
-    ASSERT_TRUE((GOOGLE_NAMESPACE::is_convertible<int, long>::value));
-    ASSERT_TRUE((GOOGLE_NAMESPACE::is_convertible<long, int>::value));
-
-    ASSERT_TRUE((GOOGLE_NAMESPACE::is_convertible<int*, void*>::value));
-    ASSERT_FALSE((GOOGLE_NAMESPACE::is_convertible<void*, int*>::value));
-
-    ASSERT_TRUE((GOOGLE_NAMESPACE::is_convertible<Derived*, Base*>::value));
-    ASSERT_FALSE((GOOGLE_NAMESPACE::is_convertible<Base*, Derived*>::value));
-    ASSERT_TRUE((GOOGLE_NAMESPACE::is_convertible<Derived*, const Base*>::value));
-    ASSERT_FALSE((GOOGLE_NAMESPACE::is_convertible<const Derived*, Base*>::value));
-#endif  // #ifdef MSC_VER
+  static void TestIsSame() {
+    typedef int int32;
+    typedef long int64;
+
+    ASSERT_TRUE((GOOGLE_NAMESPACE::is_same<int32, int32>::value));
+    ASSERT_FALSE((GOOGLE_NAMESPACE::is_same<int32, int64>::value));
+    ASSERT_FALSE((GOOGLE_NAMESPACE::is_same<int64, int32>::value));
+    ASSERT_FALSE((GOOGLE_NAMESPACE::is_same<int, const int>::value));
+
+    ASSERT_TRUE((GOOGLE_NAMESPACE::is_same<void, void>::value));
+    ASSERT_FALSE((GOOGLE_NAMESPACE::is_same<void, int>::value));
+    ASSERT_FALSE((GOOGLE_NAMESPACE::is_same<int, void>::value));
+
+    ASSERT_TRUE((GOOGLE_NAMESPACE::is_same<int*, int*>::value));
+    ASSERT_TRUE((GOOGLE_NAMESPACE::is_same<void*, void*>::value));
+    ASSERT_FALSE((GOOGLE_NAMESPACE::is_same<int*, void*>::value));
+    ASSERT_FALSE((GOOGLE_NAMESPACE::is_same<void*, int*>::value));
+    ASSERT_FALSE((GOOGLE_NAMESPACE::is_same<void*, const void*>::value));
+    ASSERT_FALSE((GOOGLE_NAMESPACE::is_same<void*, void* const>::value));
+
+    ASSERT_TRUE((GOOGLE_NAMESPACE::is_same<Base*, Base*>::value));
+    ASSERT_TRUE((GOOGLE_NAMESPACE::is_same<Derived*, Derived*>::value));
+    ASSERT_FALSE((GOOGLE_NAMESPACE::is_same<Base*, Derived*>::value));
+    ASSERT_FALSE((GOOGLE_NAMESPACE::is_same<Derived*, Base*>::value));
   }
 
 };  // end class TypeTraitsTest
@@ -472,7 +482,7 @@ class TypeTraitsTest {
 }   // end anonymous namespace
 
 
-int main(int argc, char **argv) {
+int main(int /*argc*/, char ** /*argv*/) {
   TypeTraitsTest::TestIsInteger();
   TypeTraitsTest::TestIsFloating();
   TypeTraitsTest::TestIsReference();
@@ -486,7 +496,7 @@ int main(int argc, char **argv) {
   TypeTraitsTest::TestRemoveVolatile();
   TypeTraitsTest::TestRemoveReference();
   TypeTraitsTest::TestRemoveCV();
-  TypeTraitsTest::TestIsConvertible();
+  TypeTraitsTest::TestIsSame();
   printf("PASS\n");
   return 0;
 }

data/ext/sparsehash-1.8.1/vsprojects/hashtable_test/hashtable_test.vcproj

@@ -0,0 +1,197 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="7.10"
+	Name="hashtable_test"
+	ProjectGUID="{FCDB3718-F01C-4DE4-B9F5-E10F2C5C0535}"
+	Keyword="Win32Proj">
+	<Platforms>
+		<Platform
+			Name="Win32"/>
+	</Platforms>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
+			IntermediateDirectory="$(ConfigurationName)"
+			ConfigurationType="1"
+			CharacterSet="2">
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"
+				MinimalRebuild="TRUE"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="5"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				DebugInformationFormat="4"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				OutputFile="$(OutDir)/hashtable_test.exe"
+				LinkIncremental="2"
+				GenerateDebugInformation="TRUE"
+				ProgramDatabaseFile="$(OutDir)/hashtable_test.pdb"
+				SubSystem="1"
+				TargetMachine="1"/>
+			<Tool
+				Name="VCMIDLTool"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"/>
+			<Tool
+				Name="VCWebDeploymentTool"/>
+			<Tool
+				Name="VCManagedWrapperGeneratorTool"/>
+			<Tool
+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
+			IntermediateDirectory="$(ConfigurationName)"
+			ConfigurationType="1"
+			CharacterSet="2">
+			<Tool
+				Name="VCCLCompilerTool"
+				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
+				RuntimeLibrary="4"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				DebugInformationFormat="3"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				OutputFile="$(OutDir)/hashtable_test.exe"
+				LinkIncremental="1"
+				GenerateDebugInformation="TRUE"
+				SubSystem="1"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				TargetMachine="1"/>
+			<Tool
+				Name="VCMIDLTool"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"/>
+			<Tool
+				Name="VCWebDeploymentTool"/>
+			<Tool
+				Name="VCManagedWrapperGeneratorTool"/>
+			<Tool
+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}">
+			<File
+				RelativePath="..\..\src\hashtable_test.cc">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						AdditionalIncludeDirectories="..\..\src\windows; ..\..\src"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						AdditionalIncludeDirectories="..\..\src\windows; ..\..\src"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\..\src\windows\port.cc">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						AdditionalIncludeDirectories="..\..\src\windows; ..\..\src"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						AdditionalIncludeDirectories="..\..\src\windows; ..\..\src"/>
+				</FileConfiguration>
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}">
+			<File
+				RelativePath="..\..\src\windows\config.h">
+			</File>
+			<File
+				RelativePath="..\..\src\google\dense_hash_map">
+			</File>
+			<File
+				RelativePath="..\..\src\google\dense_hash_set">
+			</File>
+			<File
+				RelativePath="..\..\src\google\sparsehash\densehashtable.h">
+			</File>
+			<File
+				RelativePath="..\..\src\windows\port.h">
+			</File>
+			<File
+				RelativePath="..\..\src\google\sparse_hash_map">
+			</File>
+			<File
+				RelativePath="..\..\src\google\sparse_hash_set">
+			</File>
+			<File
+				RelativePath="..\..\src\windows\google\sparsehash\sparseconfig.h">
+			</File>
+			<File
+				RelativePath="..\..\src\google\sparsehash\sparsehashtable.h">
+			</File>
+			<File
+				RelativePath="..\..\src\google\sparsehash\hashtable-common.h">
+			</File>
+			<File
+				RelativePath="..\..\src\google\sparsetable">
+			</File>
+			<File
+				RelativePath="..\..\src\google\sparsehash\libc_allocator_with_realloc.h">
+			</File>
+			<File
+				RelativePath="..\..\src\google\type_traits.h">
+			</File>
+			<File
+				RelativePath="..\..\src\testutil.h">
+			</File>
+			<File
+				RelativePath="..\..\src\hash_test_interface.h">
+			</File>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>